diff --git a/search_api_db/tests/src/Kernel/BackendTest.php b/search_api_db/tests/src/Kernel/BackendTest.php
index 793aabb..5c43111 100644
--- a/search_api_db/tests/src/Kernel/BackendTest.php
+++ b/search_api_db/tests/src/Kernel/BackendTest.php
@@ -157,8 +157,8 @@ class BackendTest extends KernelTestBase {
     $index = $this->getIndex();
     $this->assertTrue((bool) $index, 'The index was successfully created.');
 
-    $this->assertEquals($index->getTracker()->getTotalItemsCount(), 5, 'Correct item count.');
-    $this->assertEquals($index->getTracker()->getIndexedItemsCount(), 0, 'All items still need to be indexed.');
+    $this->assertEquals(5, $index->getTracker()->getTotalItemsCount(), 'Correct item count.');
+    $this->assertEquals(0, $index->getTracker()->getIndexedItemsCount(), 'All items still need to be indexed.');
   }
 
   /**
@@ -260,8 +260,8 @@ class BackendTest extends KernelTestBase {
    */
   protected function searchNoResults() {
     $results = $this->buildSearch('test')->execute();
-    $this->assertEquals($results->getResultCount(), 0, 'No search results returned without indexing.');
-    $this->assertEquals(array_keys($results->getResultItems()), array(), 'No search results returned without indexing.');
+    $this->assertEquals(0, $results->getResultCount(), 'No search results returned without indexing.');
+    $this->assertEquals(array(), array_keys($results->getResultItems()), 'No search results returned without indexing.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
   }
@@ -271,27 +271,27 @@ class BackendTest extends KernelTestBase {
    */
   protected function searchSuccess1() {
     $results = $this->buildSearch('test')->range(1, 2)->sort('id', QueryInterface::SORT_ASC)->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Search for »test« returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(2, 3)), 'Search for »test« returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'Search for »test« returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(2, 3)), array_keys($results->getResultItems()), 'Search for »test« returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $ids = $this->getItemIds(array(2));
     $id = reset($ids);
-    if ($this->assertEquals(key($results->getResultItems()), $id)) {
-      $this->assertEquals($results->getResultItems()[$id]->getId(), $id);
-      $this->assertEquals($results->getResultItems()[$id]->getDatasourceId(), 'entity:entity_test');
+    if ($this->assertEquals($id, key($results->getResultItems()))) {
+      $this->assertEquals($id, $results->getResultItems()[$id]->getId());
+      $this->assertEquals('entity:entity_test', $results->getResultItems()[$id]->getDatasourceId());
     }
 
     $results = $this->buildSearch('test foo')->sort('id', QueryInterface::SORT_ASC)->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'Search for »test foo« returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4)), 'Search for »test foo« returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'Search for »test foo« returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4)), array_keys($results->getResultItems()),'Search for »test foo« returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('foo', array('type,item'))->sort('id', QueryInterface::SORT_ASC)->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'Search for »foo« returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2)), 'Search for »foo« returned correct result.');
+    $this->assertEquals(2, $results->getResultCount(), 'Search for »foo« returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2)), array_keys($results->getResultItems()), 'Search for »foo« returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -311,8 +311,8 @@ class BackendTest extends KernelTestBase {
       ),
     );
     $results = $this->buildSearch($keys)->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Complex search 1 returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(4)), 'Complex search 1 returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Complex search 1 returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(4)), array_keys($results->getResultItems()), 'Complex search 1 returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
   }
@@ -335,7 +335,7 @@ class BackendTest extends KernelTestBase {
     $query->setOption('search_api_facets', $facets);
     $query->range(0, 0);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'OR facets query returned correct number of results.');
+    $this->assertEquals(2, $results->getResultCount(), 'OR facets query returned correct number of results.');
     $expected = array(
       array('count' => 2, 'filter' => '"article_category"'),
       array('count' => 2, 'filter' => '"item_category"'),
@@ -362,7 +362,7 @@ class BackendTest extends KernelTestBase {
     $query->setOption('search_api_facets', $facets);
     $query->range(0, 0);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'OR facets query returned correct number of results.');
+    $this->assertEquals(2, $results->getResultCount(), 'OR facets query returned correct number of results.');
     $expected = array(
       array('count' => 2, 'filter' => '"article_category"'),
       array('count' => 2, 'filter' => '"item_category"'),
@@ -395,26 +395,26 @@ class BackendTest extends KernelTestBase {
    */
   protected function searchSuccess2() {
     $results = $this->buildSearch('test')->range(1, 2)->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Search for »test« returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(4, 1)), 'Search for »test« returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(),'Search for »test« returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(4, 1)), array_keys($results->getResultItems()), 'Search for »test« returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch(NULL, array('body,test foobar'))->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Search with multi-term fulltext filter returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3)), 'Search with multi-term fulltext filter returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Search with multi-term fulltext filter returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3)), array_keys($results->getResultItems()), 'Search with multi-term fulltext filter returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('test foo')->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Search for »test foo« returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(2, 4, 1, 3)), 'Search for »test foo« returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'Search for »test foo« returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(2, 4, 1, 3)), array_keys($results->getResultItems()), 'Search for »test foo« returned correct result.');
     $this->assertIgnored($results, array('foo'), 'Short key was ignored.');
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('foo', array('type,item'))->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'Search for »foo« returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 3)), 'Search for »foo« returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'Search for »foo« returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 3)), array_keys($results->getResultItems()), 'Search for »foo« returned correct result.');
     $this->assertIgnored($results, array('foo'), 'Short key was ignored.');
     $this->assertWarnings($results, array((string) $this->t('No valid search keys were present in the query.')), '"No valid keys" warning was displayed.');
 
@@ -434,8 +434,8 @@ class BackendTest extends KernelTestBase {
       ),
     );
     $results = $this->buildSearch($keys)->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Complex search 1 returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3)), 'Complex search 1 returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Complex search 1 returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3)), array_keys($results->getResultItems()), 'Complex search 1 returned correct result.');
     $this->assertIgnored($results, array('baz', 'bar'), 'Correct keys were ignored.');
     $this->assertWarnings($results);
 
@@ -455,14 +455,14 @@ class BackendTest extends KernelTestBase {
       ),
     );
     $results = $this->buildSearch($keys)->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Complex search 2 returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3)), 'Complex search 2 returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Complex search 2 returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3)), array_keys($results->getResultItems()), 'Complex search 2 returned correct result.');
     $this->assertIgnored($results, array('baz', 'bar'), 'Correct keys were ignored.');
     $this->assertWarnings($results);
 
     $results = $this->buildSearch(NULL, array('keywords,orange'))->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'Filter query 1 on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 5)), 'Filter query 1 on multi-valued field returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'Filter query 1 on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 5)), array_keys($results->getResultItems()), 'Filter query 1 on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -471,26 +471,26 @@ class BackendTest extends KernelTestBase {
       'keywords,apple',
     );
     $results = $this->buildSearch(NULL, $conditions)->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Filter query 2 on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(2)), 'Filter query 2 on multi-valued field returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Filter query 2 on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(2)), array_keys($results->getResultItems()), 'Filter query 2 on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch()->addCondition('keywords', 'orange', '<>')->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'Negated filter on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3, 4)), 'Negated filter on multi-valued field returned correct result.');
+    $this->assertEquals(2, $results->getResultCount(), 'Negated filter on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3, 4)), array_keys($results->getResultItems()), 'Negated filter on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch()->addCondition('keywords', NULL)->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Query with NULL filter returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3)), 'Query with NULL filter returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Query with NULL filter returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3)), array_keys($results->getResultItems()), 'Query with NULL filter returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch()->addCondition('keywords', NULL, '<>')->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Query with NOT NULL filter returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4, 5)), 'Query with NOT NULL filter returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'Query with NOT NULL filter returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4, 5)), array_keys($results->getResultItems()), 'Query with NOT NULL filter returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
   }
@@ -501,8 +501,8 @@ class BackendTest extends KernelTestBase {
   protected function regressionTests() {
     // Regression tests for #2007872.
     $results = $this->buildSearch('test')->sort('id', QueryInterface::SORT_ASC)->sort('type', QueryInterface::SORT_ASC)->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Sorting on field with NULLs returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 3, 4)), 'Sorting on field with NULLs returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'Sorting on field with NULLs returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 3, 4)), array_keys($results->getResultItems()), 'Sorting on field with NULLs returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -513,8 +513,8 @@ class BackendTest extends KernelTestBase {
     $query->addConditionGroup($conditions);
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'OR filter on field with NULLs returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3, 4, 5)), 'OR filter on field with NULLs returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'OR filter on field with NULLs returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3, 4, 5)), array_keys($results->getResultItems()), 'OR filter on field with NULLs returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -526,8 +526,8 @@ class BackendTest extends KernelTestBase {
     $query->addConditionGroup($conditions);
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'OR filter on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4, 5)), 'OR filter on multi-valued field returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'OR filter on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4, 5)), array_keys($results->getResultItems()), 'OR filter on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -542,8 +542,8 @@ class BackendTest extends KernelTestBase {
     $query->addConditionGroup($conditions);
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'Multiple OR filters on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(2, 4, 5)), 'Multiple OR filters on multi-valued field returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'Multiple OR filters on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(2, 4, 5)), array_keys($results->getResultItems()), 'Multiple OR filters on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -560,8 +560,8 @@ class BackendTest extends KernelTestBase {
     $query->addConditionGroup($conditions1);
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'Complex nested filters on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(2, 4, 5)), 'Complex nested filters on multi-valued field returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'Complex nested filters on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(2, 4, 5)), array_keys($results->getResultItems()), 'Complex nested filters on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -583,7 +583,7 @@ class BackendTest extends KernelTestBase {
     );
     $type_facets = $results->getExtraData('search_api_facets')['category'];
     usort($type_facets, array($this, 'facetCompare'));
-    $this->assertEquals($type_facets, $expected, 'Correct facets were returned');
+    $this->assertEquals($expected, $type_facets, 'Correct facets were returned');
 
     $query = $this->buildSearch();
     $facets['category']['missing'] = FALSE;
@@ -596,7 +596,7 @@ class BackendTest extends KernelTestBase {
     );
     $type_facets = $results->getExtraData('search_api_facets')['category'];
     usort($type_facets, array($this, 'facetCompare'));
-    $this->assertEquals($type_facets, $expected, 'Correct facets were returned');
+    $this->assertEquals($expected, $type_facets, 'Correct facets were returned');
 
     // Regression tests for #2111753.
     $keys = array(
@@ -607,15 +607,15 @@ class BackendTest extends KernelTestBase {
     $query = $this->buildSearch($keys, array(), array('name'));
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 3, 'OR keywords returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4)), 'OR keywords returned correct result.');
+    $this->assertEquals(3, $results->getResultCount(), 'OR keywords returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4)), array_keys($results->getResultItems()), 'OR keywords returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $query = $this->buildSearch($keys, array(), array('name', 'body'));
     $query->range(0, 0);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 5, 'Multi-field OR keywords returned correct number of results.');
+    $this->assertEquals(5, $results->getResultCount(), 'Multi-field OR keywords returned correct number of results.');
     $this->assertFalse($results->getResultItems(), 'Multi-field OR keywords returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
@@ -633,8 +633,8 @@ class BackendTest extends KernelTestBase {
     $query = $this->buildSearch($keys, array(), array('name'));
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Nested OR keywords returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4, 5)), 'Nested OR keywords returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'Nested OR keywords returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4, 5)), array_keys($results->getResultItems()), 'Nested OR keywords returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -654,8 +654,8 @@ class BackendTest extends KernelTestBase {
     $query = $this->buildSearch($keys, array(), array('name', 'body'));
     $query->sort('id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'Nested multi-field OR keywords returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4, 5)), 'Nested multi-field OR keywords returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'Nested multi-field OR keywords returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4, 5)), array_keys($results->getResultItems()), 'Nested multi-field OR keywords returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -667,8 +667,8 @@ class BackendTest extends KernelTestBase {
       'bar',
     );
     $results = $this->buildSearch($keys)->sort('search_api_id', QueryInterface::SORT_ASC)->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'Negated AND fulltext search returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3, 4)), 'Negated AND fulltext search returned correct result.');
+    $this->assertEquals(2, $results->getResultCount(), 'Negated AND fulltext search returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3, 4)), array_keys($results->getResultItems()), 'Negated AND fulltext search returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -679,8 +679,8 @@ class BackendTest extends KernelTestBase {
       'baz',
     );
     $results = $this->buildSearch($keys)->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Negated OR fulltext search returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3)), 'Negated OR fulltext search returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Negated OR fulltext search returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3)), array_keys($results->getResultItems()), 'Negated OR fulltext search returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -695,8 +695,8 @@ class BackendTest extends KernelTestBase {
       ),
     );
     $results = $this->buildSearch($keys)->sort('search_api_id', QueryInterface::SORT_ASC)->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'Nested NOT AND fulltext search returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3, 4)), 'Nested NOT AND fulltext search returned correct result.');
+    $this->assertEquals(2, $results->getResultCount(), 'Nested NOT AND fulltext search returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3, 4)), array_keys($results->getResultItems()), 'Nested NOT AND fulltext search returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -705,15 +705,15 @@ class BackendTest extends KernelTestBase {
     $query->addCondition('category', NULL);
     $query->sort('search_api_id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'NULL filter returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(3)), 'NULL filter returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'NULL filter returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(3)), array_keys($results->getResultItems()), 'NULL filter returned correct result.');
 
     $query = $this->buildSearch();
     $query->addCondition('category', NULL, '<>');
     $query->sort('search_api_id', QueryInterface::SORT_ASC);
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 4, 'NOT NULL filter returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 2, 4, 5)), 'NOT NULL filter returned correct result.');
+    $this->assertEquals(4, $results->getResultCount(), 'NOT NULL filter returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 2, 4, 5)), array_keys($results->getResultItems()), 'NOT NULL filter returned correct result.');
 
     // Regression tests for #1658964.
     $query = $this->buildSearch();
@@ -734,7 +734,7 @@ class BackendTest extends KernelTestBase {
     );
     $facets = $results->getExtraData('search_api_facets', array())['type'];
     usort($facets, array($this, 'facetCompare'));
-    $this->assertEquals($facets, $expected, 'Correct facets were returned');
+    $this->assertEquals($expected, $facets, 'Correct facets were returned');
 
     // Regression tests for #2469547.
     $query = $this->buildSearch();
@@ -761,7 +761,7 @@ class BackendTest extends KernelTestBase {
     // both occur once, so we have to manually sort the returned facets first.
     $facets = $results->getExtraData('search_api_facets', array())['body'];
     usort($facets, array($this, 'facetCompare'));
-    $this->assertEquals($facets, $expected, 'Correct facets were returned for a fulltext field.');
+    $this->assertEquals($expected, $facets, 'Correct facets were returned for a fulltext field.');
 
     // Regression tests for #1403916.
     $query = $this->buildSearch('test foo');
@@ -781,42 +781,42 @@ class BackendTest extends KernelTestBase {
     );
     $facets = $results->getExtraData('search_api_facets', array())['type'];
     usort($facets, array($this, 'facetCompare'));
-    $this->assertEquals($facets, $expected, 'Correct facets were returned');
+    $this->assertEquals($expected, $facets, 'Correct facets were returned');
 
     // Regression tests for #2557291.
     $results = $this->buildSearch('case')->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Search for lowercase "case" returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1)), 'Search for lowercase "case" returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Search for lowercase "case" returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1)), array_keys($results->getResultItems()), 'Search for lowercase "case" returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('Case')->sort('search_api_id')->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'Search for capitalized "Case" returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 3)), 'Search for capitalized "Case" returned correct result.');
+    $this->assertEquals(2, $results->getResultCount(), 'Search for capitalized "Case" returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 3)), array_keys($results->getResultItems()), 'Search for capitalized "Case" returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('CASE')->execute();
-    $this->assertEquals($results->getResultCount(), 0, 'Search for non-existent uppercase version of "CASE" returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), array(), 'Search for non-existent uppercase version of "CASE" returned correct result.');
+    $this->assertEquals(0, $results->getResultCount(), 'Search for non-existent uppercase version of "CASE" returned correct number of results.');
+    $this->assertEquals(array(), array_keys($results->getResultItems()), 'Search for non-existent uppercase version of "CASE" returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('föö')->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Search for keywords with umlauts returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1)), 'Search for keywords with umlauts returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Search for keywords with umlauts returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1)), array_keys($results->getResultItems()), 'Search for keywords with umlauts returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch('smile' . json_decode('"\u1F601"'))->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Search for keywords with umlauts returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1)), 'Search for keywords with umlauts returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Search for keywords with umlauts returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1)), array_keys($results->getResultItems()), 'Search for keywords with umlauts returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $results = $this->buildSearch()->addCondition('keywords', 'grape', '<>')->execute();
-    $this->assertEquals($results->getResultCount(), 2, 'Negated filter on multi-valued field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(1, 3)), 'Negated filter on multi-valued field returned correct result.');
+    $this->assertEquals(2, $results->getResultCount(), 'Negated filter on multi-valued field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(1, 3)), array_keys($results->getResultItems()), 'Negated filter on multi-valued field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
   }
@@ -894,15 +894,15 @@ class BackendTest extends KernelTestBase {
 
     $query = $this->buildSearch(NULL, array('prices,3.25'));
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Filter on decimal field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(6)), 'Filter on decimal field returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Filter on decimal field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(6)), array_keys($results->getResultItems()), 'Filter on decimal field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
     $query = $this->buildSearch(NULL, array('prices,3.5'));
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Filter on decimal field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(6)), 'Filter on decimal field returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Filter on decimal field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(6)), array_keys($results->getResultItems()), 'Filter on decimal field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -915,7 +915,7 @@ class BackendTest extends KernelTestBase {
       ))->save();
 
     $count = $this->indexItems($this->indexId);
-    $this->assertEquals($count, 1, 'Indexing an item with an empty value for a non string field worked.');
+    $this->assertEquals(1, $count, 'Indexing an item with an empty value for a non string field worked.');
 
     // Regression test for #2471509.
     $this->addField($index, 'body');
@@ -931,20 +931,20 @@ class BackendTest extends KernelTestBase {
         'body' => 'astringlongerthanfiftycharactersthatcantbestoredbythedbbackend',
       ))->save();
     $count = $this->indexItems($this->indexId);
-    $this->assertEquals($count, 1, 'Indexing an item with a word longer than 50 characters worked.');
+    $this->assertEquals(1, $count, 'Indexing an item with a word longer than 50 characters worked.');
 
     // Regression test for #2616268.
     $index = $this->getIndex();
     $field = $index->getField('body')->setType('string');
     $index->addField($field)->save();
     $count = $this->indexItems($this->indexId);
-    $this->assertEquals($count, 8, 'Switching type from text to string worked.');
+    $this->assertEquals(8, $count, 'Switching type from text to string worked.');
 
     // For a string field, 50 characters shouldn't be a problem.
     $query = $this->buildSearch(NULL, array('body,astringlongerthanfiftycharactersthatcantbestoredbythedbbackend'));
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 1, 'Filter on new string field returned correct number of results.');
-    $this->assertEquals(array_keys($results->getResultItems()), $this->getItemIds(array(8)), 'Filter on new string field returned correct result.');
+    $this->assertEquals(1, $results->getResultCount(), 'Filter on new string field returned correct number of results.');
+    $this->assertEquals($this->getItemIds(array(8)), array_keys($results->getResultItems()), 'Filter on new string field returned correct result.');
     $this->assertIgnored($results);
     $this->assertWarnings($results);
 
@@ -967,7 +967,7 @@ class BackendTest extends KernelTestBase {
     $server->deleteAllIndexItems($index);
     $query = $this->buildSearch();
     $results = $query->execute();
-    $this->assertEquals($results->getResultCount(), 0, 'Clearing the server worked correctly.');
+    $this->assertEquals(0, $results->getResultCount(), 'Clearing the server worked correctly.');
     $this->assertTrue(Database::getConnection()->schema()->tableExists($normalized_storage_table), 'The index tables were left in place.');
 
     // Remove first the index and then the server.
@@ -1000,7 +1000,7 @@ class BackendTest extends KernelTestBase {
     $this->assertFalse(\Drupal::moduleHandler()->moduleExists('search_api_db'), 'The Database Search module was successfully uninstalled.');
 
     $tables = \Drupal::database()->schema()->findTables('search_api_db_%');
-    $this->assertEquals($tables, array(), 'All the tables of the the Database Search module have been removed.');
+    $this->assertEquals(array(), $tables, 'All the tables of the the Database Search module have been removed.');
   }
 
   /**
@@ -1014,7 +1014,7 @@ class BackendTest extends KernelTestBase {
    *   (optional) The message to be displayed with the assertion.
    */
   protected function assertIgnored(ResultSetInterface $results, array $ignored = array(), $message = 'No keys were ignored.') {
-    $this->assertEquals($results->getIgnoredSearchKeys(), $ignored, $message);
+    $this->assertEquals($ignored, $results->getIgnoredSearchKeys(), $message);
   }
 
   /**
@@ -1028,7 +1028,7 @@ class BackendTest extends KernelTestBase {
    *   (optional) The message to be displayed with the assertion.
    */
   protected function assertWarnings(ResultSetInterface $results, array $warnings = array(), $message = 'No warnings were displayed.') {
-    $this->assertEquals($results->getWarnings(), $warnings, $message);
+    $this->assertEquals($warnings, $results->getWarnings(), $message);
   }
 
   /**
diff --git a/tests/src/Kernel/CustomDataTypesTest.php b/tests/src/Kernel/CustomDataTypesTest.php
index 66f291b..6ae2d46 100644
--- a/tests/src/Kernel/CustomDataTypesTest.php
+++ b/tests/src/Kernel/CustomDataTypesTest.php
@@ -121,8 +121,8 @@ class CustomDataTypesTest extends KernelTestBase {
     $processed_value = $name_field->getValues()[0];
     $processed_type = $name_field->getType();
 
-    $this->assertEquals($processed_value, $original_value, 'The processed value matches the original value');
-    $this->assertEquals($processed_type, $original_type, 'The processed type matches the original type.');
+    $this->assertEquals($original_value, $processed_value, 'The processed value matches the original value');
+    $this->assertEquals($original_type, $processed_type, 'The processed type matches the original type.');
 
     // Reset the fields on the item and change to the supported data type.
     $item->setFieldsExtracted(FALSE);
@@ -133,8 +133,8 @@ class CustomDataTypesTest extends KernelTestBase {
     $processed_value = $name_field->getValues()[0];
     $processed_type = $name_field->getType();
 
-    $this->assertEquals($processed_value, $original_value, 'The processed value matches the original value');
-    $this->assertEquals($processed_type, 'search_api_test_data_type', 'The processed type matches the new type.');
+    $this->assertEquals($original_value, $processed_value, 'The processed value matches the original value');
+    $this->assertEquals('search_api_test_data_type', $processed_type, 'The processed type matches the new type.');
 
     // Reset the fields on the item and change to the non-supported data type.
     $item->setFieldsExtracted(FALSE);
@@ -145,8 +145,8 @@ class CustomDataTypesTest extends KernelTestBase {
     $processed_value = $name_field->getValues()[0];
     $processed_type = $name_field->getType();
 
-    $this->assertEquals($processed_value, $original_value, 'The processed value matches the original value');
-    $this->assertEquals($processed_type, 'integer', 'The processed type matches the fallback type.');
+    $this->assertEquals($original_value, $processed_value, 'The processed value matches the original value');
+    $this->assertEquals('integer', $processed_type, 'The processed type matches the fallback type.');
 
     // Reset the fields on the item and change to the data altering data type.
     $item->setFieldsExtracted(FALSE);
@@ -157,8 +157,8 @@ class CustomDataTypesTest extends KernelTestBase {
     $processed_value = $name_field->getValues()[0];
     $processed_type = $name_field->getType();
 
-    $this->assertEquals($processed_value, strlen($original_value), 'The processed value matches the altered original value');
-    $this->assertEquals($processed_type, 'search_api_altering_test_data_type', 'The processed type matches the defined type.');
+    $this->assertEquals(strlen($original_value), $processed_value, 'The processed value matches the altered original value');
+    $this->assertEquals('search_api_altering_test_data_type', $processed_type, 'The processed type matches the defined type.');
   }
 
 }
diff --git a/tests/src/Kernel/LanguageKernelTest.php b/tests/src/Kernel/LanguageKernelTest.php
index f738f60..da369db 100644
--- a/tests/src/Kernel/LanguageKernelTest.php
+++ b/tests/src/Kernel/LanguageKernelTest.php
@@ -2,7 +2,7 @@
 
 /**
  * @file
- * Contains \Drupal\Tests\search_api\Kernel\LanguageIntegrationTest.
+ * Contains \Drupal\Tests\search_api\Kernel\LanguageKernelTest.
  */
 
 namespace Drupal\Tests\search_api\Kernel;
@@ -19,7 +19,7 @@ use Drupal\search_api\Entity\Server;
  *
  * @group search_api
  */
-class LanguageIntegrationTest extends KernelTestBase {
+class LanguageKernelTest extends KernelTestBase {
 
   /**
    * The test entity type used in the test.
@@ -129,7 +129,7 @@ class LanguageIntegrationTest extends KernelTestBase {
       'user_id' => $this->container->get('current_user')->id(),
     ));
     $entity_1->save();
-    $this->assertEquals($entity_1->language()->getId(), 'en', new FormattableMarkup('%entity_type: Entity language set to site default.', array('%entity_type' => $this->testEntityTypeId)));
+    $this->assertEquals('en', $entity_1->language()->getId(), new FormattableMarkup('%entity_type: Entity language set to site default.', array('%entity_type' => $this->testEntityTypeId)));
     $this->assertFalse($entity_1->getTranslationLanguages(FALSE), new FormattableMarkup('%entity_type: No translations are available', array('%entity_type' => $this->testEntityTypeId)));
 
     /** @var \Drupal\entity_test\Entity\EntityTestMul $entity_2 */
@@ -139,7 +139,7 @@ class LanguageIntegrationTest extends KernelTestBase {
       'user_id' => $this->container->get('current_user')->id(),
     ));
     $entity_2->save();
-    $this->assertEquals($entity_2->language()->getId(), 'en', new FormattableMarkup('%entity_type: Entity language set to site default.', array('%entity_type' => $this->testEntityTypeId)));
+    $this->assertEquals('en', $entity_2->language()->getId(), new FormattableMarkup('%entity_type: Entity language set to site default.', array('%entity_type' => $this->testEntityTypeId)));
     $this->assertFalse($entity_2->getTranslationLanguages(FALSE), new FormattableMarkup('%entity_type: No translations are available', array('%entity_type' => $this->testEntityTypeId)));
 
     // Test that the datasource returns the correct item IDs.
@@ -150,19 +150,19 @@ class LanguageIntegrationTest extends KernelTestBase {
       '1:en',
       '2:en',
     );
-    $this->assertEquals($datasource_item_ids, $expected, 'Datasource returns correct item ids.');
+    $this->assertEquals($expected, $datasource_item_ids, 'Datasource returns correct item ids.');
 
     // Test indexing the new entity.
-    $this->assertEquals($this->index->getTracker()->getIndexedItemsCount(), 0, 'The index is empty.');
-    $this->assertEquals($this->index->getTracker()->getTotalItemsCount(), 2, 'There are two items to be indexed.');
+    $this->assertEquals(0, $this->index->getTracker()->getIndexedItemsCount(), 'The index is empty.');
+    $this->assertEquals(2, $this->index->getTracker()->getTotalItemsCount(), 'There are two items to be indexed.');
     $this->index->indexItems();
-    $this->assertEquals($this->index->getTracker()->getIndexedItemsCount(), 2, 'Two items have been indexed.');
+    $this->assertEquals(2, $this->index->getTracker()->getIndexedItemsCount(), 'Two items have been indexed.');
 
     // Now, make the first entity language-specific by assigning a language.
     $default_langcode = $this->langcodes[0];
     $entity_1->get('langcode')->setValue($default_langcode);
     $entity_1->save();
-    $this->assertEquals($entity_1->language(), \Drupal::languageManager()->getLanguage($this->langcodes[0]), new FormattableMarkup('%entity_type: Entity language retrieved.', array('%entity_type' => $this->testEntityTypeId)));
+    $this->assertEquals(\Drupal::languageManager()->getLanguage($this->langcodes[0]), $entity_1->language(), new FormattableMarkup('%entity_type: Entity language retrieved.', array('%entity_type' => $this->testEntityTypeId)));
     $this->assertFalse($entity_1->getTranslationLanguages(FALSE), new FormattableMarkup('%entity_type: No translations are available', array('%entity_type' => $this->testEntityTypeId)));
 
     // Test that the datasource returns the correct item IDs.
@@ -172,11 +172,11 @@ class LanguageIntegrationTest extends KernelTestBase {
       '1:' . $this->langcodes[0],
       '2:en',
     );
-    $this->assertEquals($datasource_item_ids, $expected, 'Datasource returns correct item ids.');
+    $this->assertEquals($expected, $datasource_item_ids, 'Datasource returns correct item ids.');
 
     // Test that the index needs to be updated.
-    $this->assertEquals($this->index->getTracker()->getIndexedItemsCount(), 1, 'The updated item needs to be reindexed.');
-    $this->assertEquals($this->index->getTracker()->getTotalItemsCount(), 2, 'There are two items in total.');
+    $this->assertEquals(1, $this->index->getTracker()->getIndexedItemsCount(), 'The updated item needs to be reindexed.');
+    $this->assertEquals(2, $this->index->getTracker()->getTotalItemsCount(), 'There are two items in total.');
 
     // Set two translations for the first entity and test that the datasource
     // returns three separate item IDs, one for each translation.
@@ -194,11 +194,11 @@ class LanguageIntegrationTest extends KernelTestBase {
       '1:' . $this->langcodes[2],
       '2:en',
     );
-    $this->assertEquals($datasource_item_ids, $expected, 'Datasource returns correct item ids for a translated entity.');
+    $this->assertEquals($expected, $datasource_item_ids, 'Datasource returns correct item ids for a translated entity.');
 
     // Test that the index needs to be updated.
-    $this->assertEquals($this->index->getTracker()->getIndexedItemsCount(), 1, 'The updated items needs to be reindexed.');
-    $this->assertEquals($this->index->getTracker()->getTotalItemsCount(), 4, 'There are four items in total.');
+    $this->assertEquals(1, $this->index->getTracker()->getIndexedItemsCount(), 'The updated items needs to be reindexed.');
+    $this->assertEquals(4, $this->index->getTracker()->getTotalItemsCount(), 'There are four items in total.');
 
     // Delete one translation and test that the datasource returns only three
     // items.
@@ -212,13 +212,13 @@ class LanguageIntegrationTest extends KernelTestBase {
       '1:' . $this->langcodes[1],
       '2:en',
     );
-    $this->assertEquals($datasource_item_ids, $expected, 'Datasource returns correct item ids for a translated entity.');
+    $this->assertEquals($expected, $datasource_item_ids, 'Datasource returns correct item ids for a translated entity.');
 
     // Test reindexing.
-    $this->assertEquals($this->index->getTracker()->getTotalItemsCount(), 3, 'There are three items in total.');
-    $this->assertEquals($this->index->getTracker()->getIndexedItemsCount(), 1, 'The updated items needs to be reindexed.');
+    $this->assertEquals(3, $this->index->getTracker()->getTotalItemsCount(), 'There are three items in total.');
+    $this->assertEquals(1, $this->index->getTracker()->getIndexedItemsCount(), 'The updated items needs to be reindexed.');
     $this->index->indexItems();
-    $this->assertEquals($this->index->getTracker()->getIndexedItemsCount(), 3, 'Three items are indexed.');
+    $this->assertEquals(3, $this->index->getTracker()->getIndexedItemsCount(), 'Three items are indexed.');
   }
 
 }