updated core and modules

core/modules/taxonomy/tests/modules/taxonomy_crud/taxonomy_crud.info.yml

@@ -7,8 +7,8 @@ package: Testing
 dependencies:
   - taxonomy
 
-# Information added by Drupal.org packaging script on 2016-08-03
-version: '8.1.8'
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
 core: '8.x'
 project: 'drupal'
-datestamp: 1470233792
+datestamp: 1502903957

core/modules/taxonomy/tests/modules/taxonomy_term_stub_test/migrations/taxonomy_term_stub_test.yml

@@ -19,7 +19,7 @@ process:
   name: name
   weight: weight
   parent:
-    plugin: migration
+    plugin: migration_lookup
     migration: taxonomy_term_stub_test
     source: parent
 destination:
@@ -27,3 +27,6 @@ destination:
 migration_dependencies:
   required:
     - vocabularies
+provider:
+  - migrate_drupal
+  - taxonomy

core/modules/taxonomy/tests/modules/taxonomy_term_stub_test/taxonomy_term_stub_test.info.yml

@@ -8,8 +8,8 @@ dependencies:
   - taxonomy
   - migrate
 
-# Information added by Drupal.org packaging script on 2016-08-03
-version: '8.1.8'
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
 core: '8.x'
 project: 'drupal'
-datestamp: 1470233792
+datestamp: 1502903957

core/modules/taxonomy/tests/modules/taxonomy_test/taxonomy_test.info.yml

@@ -0,0 +1,14 @@
+name: 'Taxonomy test'
+type: module
+description: 'Provides test hook implementations for taxonomy tests'
+package: Testing
+# version: VERSION
+# core: 8.x
+dependencies:
+  - taxonomy
+
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
+core: '8.x'
+project: 'drupal'
+datestamp: 1502903957

core/modules/taxonomy/tests/modules/taxonomy_test/taxonomy_test.module

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * @file
+ * Provides test hook implementations for taxonomy tests.
+ */
+
+use Drupal\Core\Database\Query\AlterableInterface;
+
+/**
+ * Implements hook_query_alter().
+ */
+function taxonomy_test_query_alter(AlterableInterface $query) {
+  $value = \Drupal::state()->get(__FUNCTION__);
+  if (isset($value)) {
+    \Drupal::state()->set(__FUNCTION__, ++$value);
+  }
+}
+
+/**
+ * Implements hook_query_TAG_alter().
+ */
+function taxonomy_test_query_term_access_alter(AlterableInterface $query) {
+  $value = \Drupal::state()->get(__FUNCTION__);
+  if (isset($value)) {
+    \Drupal::state()->set(__FUNCTION__, ++$value);
+  }
+}
+
+/**
+ * Implements hook_query_TAG_alter().
+ */
+function taxonomy_test_query_taxonomy_term_access_alter(AlterableInterface $query) {
+  $value = \Drupal::state()->get(__FUNCTION__);
+  if (isset($value)) {
+    \Drupal::state()->set(__FUNCTION__, ++$value);
+  }
+}

core/modules/taxonomy/tests/modules/taxonomy_test_views/taxonomy_test_views.info.yml

@@ -8,8 +8,8 @@ dependencies:
   - taxonomy
   - views
 
-# Information added by Drupal.org packaging script on 2016-08-03
-version: '8.1.8'
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
 core: '8.x'
 project: 'drupal'
-datestamp: 1470233792
+datestamp: 1502903957

core/modules/taxonomy/tests/modules/taxonomy_test_views/test_views/views.view.test_argument_taxonomy_index_tid_depth.yml

@@ -130,7 +130,7 @@ display:
           field_api_classes: false
       filters:
         status:
-          value: true
+          value: '1'
           table: node_field_data
           field: status
           plugin_id: boolean

core/modules/taxonomy/tests/modules/taxonomy_test_views/test_views/views.view.test_argument_taxonomy_vocabulary.yml

@@ -0,0 +1,174 @@
+langcode: en
+status: true
+dependencies:
+  module:
+    - taxonomy
+    - user
+id: test_argument_taxonomy_vocabulary
+label: test_argument_taxonomy_vocabulary
+module: views
+description: ''
+tag: ''
+base_table: taxonomy_term_field_data
+base_field: tid
+core: 8.x
+display:
+  default:
+    display_plugin: default
+    id: default
+    display_title: Master
+    position: 0
+    display_options:
+      access:
+        type: perm
+        options:
+          perm: 'access content'
+      cache:
+        type: tag
+        options: {  }
+      query:
+        type: views_query
+        options:
+          disable_sql_rewrite: false
+          distinct: false
+          replica: false
+          query_comment: ''
+          query_tags: {  }
+      exposed_form:
+        type: basic
+        options:
+          submit_button: Apply
+          reset_button: false
+          reset_button_label: Reset
+          exposed_sorts_label: 'Sort by'
+          expose_sort_order: true
+          sort_asc_label: Asc
+          sort_desc_label: Desc
+      pager:
+        type: none
+        options:
+          offset: 0
+      style:
+        type: default
+      row:
+        type: 'entity:taxonomy_term'
+      fields:
+        name:
+          id: name
+          table: taxonomy_term_field_data
+          field: name
+          entity_type: taxonomy_term
+          entity_field: name
+          label: ''
+          alter:
+            alter_text: false
+            make_link: false
+            absolute: false
+            trim: false
+            word_boundary: false
+            ellipsis: false
+            strip_tags: false
+            html: false
+          hide_empty: false
+          empty_zero: false
+          type: string
+          settings:
+            link_to_entity: true
+          plugin_id: term_name
+          relationship: none
+          group_type: group
+          admin_label: ''
+          exclude: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: true
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_alter_empty: true
+          click_sort_column: value
+          group_column: value
+          group_columns: {  }
+          group_rows: true
+          delta_limit: 0
+          delta_offset: 0
+          delta_reversed: false
+          delta_first_last: false
+          multi_type: separator
+          separator: ', '
+          field_api_classes: false
+          convert_spaces: false
+      filters: {  }
+      sorts: {  }
+      title: ''
+      header: {  }
+      footer: {  }
+      empty: {  }
+      relationships: {  }
+      arguments:
+        vid:
+          id: vid
+          table: taxonomy_term_field_data
+          field: vid
+          relationship: none
+          group_type: group
+          admin_label: ''
+          default_action: ignore
+          exception:
+            value: all
+            title_enable: false
+            title: All
+          title_enable: false
+          title: ''
+          default_argument_type: fixed
+          default_argument_options:
+            argument: ''
+          default_argument_skip_url: false
+          summary_options:
+            base_path: ''
+            count: true
+            items_per_page: 25
+            override: false
+          summary:
+            sort_order: asc
+            number_of_records: 0
+            format: default_summary
+          specify_validation: false
+          validate:
+            type: none
+            fail: 'not found'
+          validate_options: {  }
+          break_phrase: false
+          not: false
+          entity_type: taxonomy_term
+          entity_field: vid
+          plugin_id: vocabulary_vid
+      display_extenders: {  }
+    cache_metadata:
+      max-age: -1
+      contexts:
+        - 'languages:language_content'
+        - 'languages:language_interface'
+        - url
+        - user.permissions
+      tags: {  }
+  page_1:
+    display_plugin: page
+    id: page_1
+    display_title: Page
+    position: 1
+    display_options:
+      display_extenders: {  }
+      path: test_argument_taxonomy_vocabulary
+    cache_metadata:
+      max-age: -1
+      contexts:
+        - 'languages:language_content'
+        - 'languages:language_interface'
+        - url
+        - user.permissions
+      tags: {  }
+

core/modules/taxonomy/tests/modules/taxonomy_test_views/test_views/views.view.test_filter_taxonomy_index_tid.yml

@@ -116,7 +116,7 @@ display:
           entity_field: title
       filters:
         status:
-          value: true
+          value: '1'
           table: node_field_data
           field: status
           id: status

core/modules/taxonomy/tests/modules/taxonomy_test_views/test_views/views.view.test_filter_taxonomy_index_tid__non_existing_dependency.yml

@@ -116,7 +116,7 @@ display:
           entity_field: title
       filters:
         status:
-          value: true
+          value: '1'
           table: node_field_data
           field: status
           id: status

core/modules/taxonomy/tests/modules/taxonomy_test_views/test_views/views.view.test_filter_taxonomy_index_tid_depth.yml

@@ -116,7 +116,7 @@ display:
           entity_field: title
       filters:
         status:
-          value: true
+          value: '1'
           table: node_field_data
           field: status
           id: status

core/modules/taxonomy/tests/modules/vocabulary_serialization_test/src/VocabularyResponse.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\vocabulary_serialization_test;
+
+use Drupal\Core\Cache\CacheableResponse;
+use Drupal\taxonomy\VocabularyInterface;
+
+class VocabularyResponse extends CacheableResponse {
+
+  /**
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  public function setVocabulary(VocabularyInterface $vocabulary) {
+    $this->vocabulary = $vocabulary;
+  }
+
+}

core/modules/taxonomy/tests/modules/vocabulary_serialization_test/src/VocabularySerializationTestController.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Drupal\vocabulary_serialization_test;
+
+use Drupal\taxonomy\VocabularyInterface;
+
+class VocabularySerializationTestController {
+
+  public function vocabularyResponse(VocabularyInterface $taxonomy_vocabulary) {
+    $response = new VocabularyResponse('this is the output');
+    $response->setVocabulary($taxonomy_vocabulary);
+    return $response;
+  }
+
+}

core/modules/taxonomy/tests/modules/vocabulary_serialization_test/vocabulary_serialization_test.info.yml

@@ -0,0 +1,13 @@
+name: 'Vocabulary serialization test'
+type: module
+package: Testing
+# version: VERSION
+# core: 8.x
+dependencies:
+  - taxonomy
+
+# Information added by Drupal.org packaging script on 2017-08-16
+version: '8.3.7'
+core: '8.x'
+project: 'drupal'
+datestamp: 1502903957

core/modules/taxonomy/tests/modules/vocabulary_serialization_test/vocabulary_serialization_test.routing.yml

@@ -0,0 +1,6 @@
+vocabulary_serialization_test:
+  path: '/vocabulary_serialization_test/{taxonomy_vocabulary}'
+  defaults:
+    _controller: 'Drupal\vocabulary_serialization_test\VocabularySerializationTestController::vocabularyResponse'
+  requirements:
+    _access: 'TRUE'

core/modules/taxonomy/tests/src/Functional/EfqTest.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+/**
+ * Verifies operation of a taxonomy-based Entity Query.
+ *
+ * @group taxonomy
+ */
+class EfqTest extends TaxonomyTestBase {
+
+  /**
+   * Vocabulary for testing.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy']));
+    $this->vocabulary = $this->createVocabulary();
+  }
+
+  /**
+   * Tests that a basic taxonomy entity query works.
+   */
+  public function testTaxonomyEfq() {
+    $terms = [];
+    for ($i = 0; $i < 5; $i++) {
+      $term = $this->createTerm($this->vocabulary);
+      $terms[$term->id()] = $term;
+    }
+    $result = \Drupal::entityQuery('taxonomy_term')->execute();
+    sort($result);
+    $this->assertEqual(array_keys($terms), $result, 'Taxonomy terms were retrieved by entity query.');
+    $tid = reset($result);
+    $ids = (object) [
+      'entity_type' => 'taxonomy_term',
+      'entity_id' => $tid,
+      'bundle' => $this->vocabulary->id(),
+    ];
+    $term = _field_create_entity_from_ids($ids);
+    $this->assertEqual($term->id(), $tid, 'Taxonomy term can be created based on the IDs.');
+
+    // Create a second vocabulary and five more terms.
+    $vocabulary2 = $this->createVocabulary();
+    $terms2 = [];
+    for ($i = 0; $i < 5; $i++) {
+      $term = $this->createTerm($vocabulary2);
+      $terms2[$term->id()] = $term;
+    }
+
+    $result = \Drupal::entityQuery('taxonomy_term')
+      ->condition('vid', $vocabulary2->id())
+      ->execute();
+    sort($result);
+    $this->assertEqual(array_keys($terms2), $result, format_string('Taxonomy terms from the %name vocabulary were retrieved by entity query.', ['%name' => $vocabulary2->label()]));
+    $tid = reset($result);
+    $ids = (object) [
+      'entity_type' => 'taxonomy_term',
+      'entity_id' => $tid,
+      'bundle' => $vocabulary2->id(),
+    ];
+    $term = _field_create_entity_from_ids($ids);
+    $this->assertEqual($term->id(), $tid, 'Taxonomy term can be created based on the IDs.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/LegacyTest.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Core\Datetime\DrupalDateTime;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use \Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Posts an article with a taxonomy term and a date prior to 1970.
+ *
+ * @group taxonomy
+ */
+class LegacyTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['node', 'datetime'];
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Create a tags vocabulary for the 'article' content type.
+    $vocabulary = Vocabulary::create([
+      'name' => 'Tags',
+      'vid' => 'tags',
+    ]);
+    $vocabulary->save();
+    $field_name = 'field_' . $vocabulary->id();
+
+    $handler_settings = [
+      'target_bundles' => [
+        $vocabulary->id() => $vocabulary->id(),
+      ],
+      'auto_create' => TRUE,
+    ];
+    $this->createEntityReferenceField('node', 'article', $field_name, 'Tags', 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($field_name, [
+        'type' => 'entity_reference_autocomplete_tags',
+      ])
+      ->save();
+
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy', 'administer nodes', 'bypass node access']));
+  }
+
+  /**
+   * Test taxonomy functionality with nodes prior to 1970.
+   */
+  public function testTaxonomyLegacyNode() {
+    // Posts an article with a taxonomy term and a date prior to 1970.
+    $date = new DrupalDateTime('1969-01-01 00:00:00');
+    $edit = [];
+    $edit['title[0][value]'] = $this->randomMachineName();
+    $edit['created[0][value][date]'] = $date->format('Y-m-d');
+    $edit['created[0][value][time]'] = $date->format('H:i:s');
+    $edit['body[0][value]'] = $this->randomMachineName();
+    $edit['field_tags[target_id]'] = $this->randomMachineName();
+    $this->drupalPostForm('node/add/article', $edit, t('Save and publish'));
+    // Checks that the node has been saved.
+    $node = $this->drupalGetNodeByTitle($edit['title[0][value]']);
+    $this->assertEqual($node->getCreatedTime(), $date->getTimestamp(), 'Legacy node was saved with the right date.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/LoadMultipleTest.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\taxonomy\Entity\Term;
+
+/**
+ * Tests the loading of multiple taxonomy terms at once.
+ *
+ * @group taxonomy
+ */
+class LoadMultipleTest extends TaxonomyTestBase {
+
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy']));
+  }
+
+  /**
+   * Create a vocabulary and some taxonomy terms, ensuring they're loaded
+   * correctly using entity_load_multiple().
+   */
+  public function testTaxonomyTermMultipleLoad() {
+    // Create a vocabulary.
+    $vocabulary = $this->createVocabulary();
+
+    // Create five terms in the vocabulary.
+    $i = 0;
+    while ($i < 5) {
+      $i++;
+      $this->createTerm($vocabulary);
+    }
+    // Load the terms from the vocabulary.
+    $terms = entity_load_multiple_by_properties('taxonomy_term', ['vid' => $vocabulary->id()]);
+    $count = count($terms);
+    $this->assertEqual($count, 5, format_string('Correct number of terms were loaded. @count terms.', ['@count' => $count]));
+
+    // Load the same terms again by tid.
+    $terms2 = Term::loadMultiple(array_keys($terms));
+    $this->assertEqual($count, count($terms2), 'Five terms were loaded by tid.');
+    $this->assertEqual($terms, $terms2, 'Both arrays contain the same terms.');
+
+    // Remove one term from the array, then delete it.
+    $deleted = array_shift($terms2);
+    $deleted->delete();
+    $deleted_term = Term::load($deleted->id());
+    $this->assertFalse($deleted_term);
+
+    // Load terms from the vocabulary by vid.
+    $terms3 = entity_load_multiple_by_properties('taxonomy_term', ['vid' => $vocabulary->id()]);
+    $this->assertEqual(count($terms3), 4, 'Correct number of terms were loaded.');
+    $this->assertFalse(isset($terms3[$deleted->id()]));
+
+    // Create a single term and load it by name.
+    $term = $this->createTerm($vocabulary);
+    $loaded_terms = entity_load_multiple_by_properties('taxonomy_term', ['name' => $term->getName()]);
+    $this->assertEqual(count($loaded_terms), 1, 'One term was loaded.');
+    $loaded_term = reset($loaded_terms);
+    $this->assertEqual($term->id(), $loaded_term->id(), 'Term loaded by name successfully.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TaxonomyImageTest.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\field\Entity\FieldConfig;
+use Drupal\Tests\TestFileCreationTrait;
+use Drupal\user\RoleInterface;
+use Drupal\file\Entity\File;
+use Drupal\field\Entity\FieldStorageConfig;
+
+/**
+ * Tests access checks of private image fields.
+ *
+ * @group taxonomy
+ */
+class TaxonomyImageTest extends TaxonomyTestBase {
+
+  use TestFileCreationTrait {
+    getTestFiles as drupalGetTestFiles;
+    compareFiles as drupalCompareFiles;
+  }
+
+  /**
+   * Used taxonomy vocabulary.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['image'];
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Remove access content permission from registered users.
+    user_role_revoke_permissions(RoleInterface::AUTHENTICATED_ID, ['access content']);
+
+    $this->vocabulary = $this->createVocabulary();
+    // Add a field to the vocabulary.
+    $entity_type = 'taxonomy_term';
+    $name = 'field_test';
+    FieldStorageConfig::create([
+      'field_name' => $name,
+      'entity_type' => $entity_type,
+      'type' => 'image',
+      'settings' => [
+        'uri_scheme' => 'private',
+      ],
+    ])->save();
+    FieldConfig::create([
+      'field_name' => $name,
+      'entity_type' => $entity_type,
+      'bundle' => $this->vocabulary->id(),
+      'settings' => [],
+    ])->save();
+    entity_get_display($entity_type, $this->vocabulary->id(), 'default')
+      ->setComponent($name, [
+        'type' => 'image',
+        'settings' => [],
+      ])
+      ->save();
+    entity_get_form_display($entity_type, $this->vocabulary->id(), 'default')
+      ->setComponent($name, [
+        'type' => 'image_image',
+        'settings' => [],
+      ])
+      ->save();
+  }
+
+  public function testTaxonomyImageAccess() {
+    $user = $this->drupalCreateUser(['administer site configuration', 'administer taxonomy', 'access user profiles']);
+    $this->drupalLogin($user);
+
+    // Create a term and upload the image.
+    $files = $this->drupalGetTestFiles('image');
+    $image = array_pop($files);
+    $edit['name[0][value]'] = $this->randomMachineName();
+    $edit['files[field_test_0]'] = drupal_realpath($image->uri);
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add', $edit, t('Save'));
+    $this->drupalPostForm(NULL, ['field_test[0][alt]' => $this->randomMachineName()], t('Save'));
+    $terms = entity_load_multiple_by_properties('taxonomy_term', ['name' => $edit['name[0][value]']]);
+    $term = reset($terms);
+    $this->assertText(t('Created new term @name.', ['@name' => $term->getName()]));
+
+    // Create a user that should have access to the file and one that doesn't.
+    $access_user = $this->drupalCreateUser(['access content']);
+    $no_access_user = $this->drupalCreateUser();
+    $image = File::load($term->field_test->target_id);
+    $this->drupalLogin($access_user);
+    $this->drupalGet(file_create_url($image->getFileUri()));
+    $this->assertResponse(200, 'Private image on term is accessible with right permission');
+
+    $this->drupalLogin($no_access_user);
+    $this->drupalGet(file_create_url($image->getFileUri()));
+    $this->assertResponse(403, 'Private image on term not accessible without right permission');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TaxonomyQueryAlterTest.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Tests that appropriate query tags are added.
+ *
+ * @group taxonomy
+ */
+class TaxonomyQueryAlterTest extends BrowserTestBase {
+
+  use TaxonomyTestTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test'];
+
+  /**
+   * Tests that appropriate tags are added when querying the database.
+   */
+  public function testTaxonomyQueryAlter() {
+    // Create a new vocabulary and add a few terms to it.
+    $vocabulary = $this->createVocabulary();
+    $terms = [];
+    for ($i = 0; $i < 5; $i++) {
+      $terms[$i] = $this->createTerm($vocabulary);
+    }
+
+    // Set up hierarchy. Term 2 is a child of 1.
+    $terms[2]->parent = $terms[1]->id();
+    $terms[2]->save();
+
+    $term_storage = \Drupal::entityManager()->getStorage('taxonomy_term');
+
+    $this->setupQueryTagTestHooks();
+    $loaded_term = $term_storage->load($terms[0]->id());
+    $this->assertEqual($loaded_term->id(), $terms[0]->id(), 'First term was loaded');
+    $this->assertQueryTagTestResult(1, 0, 'TermStorage::load()');
+
+    $this->setupQueryTagTestHooks();
+    $loaded_terms = $term_storage->loadTree($vocabulary->id());
+    $this->assertEqual(count($loaded_terms), count($terms), 'All terms were loaded');
+    $this->assertQueryTagTestResult(1, 1, 'TermStorage::loadTree()');
+
+    $this->setupQueryTagTestHooks();
+    $loaded_terms = $term_storage->loadParents($terms[2]->id());
+    $this->assertEqual(count($loaded_terms), 1, 'All parent terms were loaded');
+    $this->assertQueryTagTestResult(2, 1, 'TermStorage::loadParents()');
+
+    $this->setupQueryTagTestHooks();
+    $loaded_terms = $term_storage->loadChildren($terms[1]->id());
+    $this->assertEqual(count($loaded_terms), 1, 'All child terms were loaded');
+    $this->assertQueryTagTestResult(2, 1, 'TermStorage::loadChildren()');
+
+    $this->setupQueryTagTestHooks();
+    $query = db_select('taxonomy_term_data', 't');
+    $query->addField('t', 'tid');
+    $query->addTag('taxonomy_term_access');
+    $tids = $query->execute()->fetchCol();
+    $this->assertEqual(count($tids), count($terms), 'All term IDs were retrieved');
+    $this->assertQueryTagTestResult(1, 1, 'custom db_select() with taxonomy_term_access tag (preferred)');
+
+    $this->setupQueryTagTestHooks();
+    $query = db_select('taxonomy_term_data', 't');
+    $query->addField('t', 'tid');
+    $query->addTag('term_access');
+    $tids = $query->execute()->fetchCol();
+    $this->assertEqual(count($tids), count($terms), 'All term IDs were retrieved');
+    $this->assertQueryTagTestResult(1, 1, 'custom db_select() with term_access tag (deprecated)');
+
+    $this->setupQueryTagTestHooks();
+    $query = \Drupal::entityQuery('taxonomy_term');
+    $query->addTag('taxonomy_term_access');
+    $result = $query->execute();
+    $this->assertEqual(count($result), count($terms), 'All term IDs were retrieved');
+    $this->assertQueryTagTestResult(1, 1, 'custom EntityFieldQuery with taxonomy_term_access tag (preferred)');
+
+    $this->setupQueryTagTestHooks();
+    $query = \Drupal::entityQuery('taxonomy_term');
+    $query->addTag('term_access');
+    $result = $query->execute();
+    $this->assertEqual(count($result), count($terms), 'All term IDs were retrieved');
+    $this->assertQueryTagTestResult(1, 1, 'custom EntityFieldQuery with term_access tag (deprecated)');
+  }
+
+  /**
+   * Sets up the hooks in the test module.
+   */
+  protected function setupQueryTagTestHooks() {
+    taxonomy_terms_static_reset();
+    \Drupal::state()->set('taxonomy_test_query_alter', 0);
+    \Drupal::state()->set('taxonomy_test_query_term_access_alter', 0);
+    \Drupal::state()->set('taxonomy_test_query_taxonomy_term_access_alter', 0);
+  }
+
+  /**
+   * Verifies invocation of the hooks in the test module.
+   *
+   * @param int $expected_generic_invocations
+   *   The number of times the generic query_alter hook is expected to have
+   *   been invoked.
+   * @param int $expected_specific_invocations
+   *   The number of times the tag-specific query_alter hooks are expected to
+   *   have been invoked.
+   * @param string $method
+   *   A string describing the invoked function which generated the query.
+   */
+  protected function assertQueryTagTestResult($expected_generic_invocations, $expected_specific_invocations, $method) {
+    $this->assertIdentical($expected_generic_invocations, \Drupal::state()->get('taxonomy_test_query_alter'), 'hook_query_alter() invoked when executing ' . $method);
+    $this->assertIdentical($expected_specific_invocations, \Drupal::state()->get('taxonomy_test_query_term_access_alter'), 'Deprecated hook_query_term_access_alter() invoked when executing ' . $method);
+    $this->assertIdentical($expected_specific_invocations, \Drupal::state()->get('taxonomy_test_query_taxonomy_term_access_alter'), 'Preferred hook_query_taxonomy_term_access_alter() invoked when executing ' . $method);
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TaxonomyTermPagerTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+/**
+ * Ensures that the term pager works properly.
+ *
+ * @group taxonomy
+ */
+class TaxonomyTermPagerTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy'];
+
+  /**
+   * Vocabulary for testing.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy', 'bypass node access']));
+    $this->vocabulary = $this->createVocabulary();
+  }
+
+  /**
+   * Tests that the pager is displayed properly on the term overview page.
+   */
+  public function testTaxonomyTermOverviewPager() {
+    // Set limit to 3 terms per page.
+    $this->config('taxonomy.settings')
+      ->set('terms_per_page_admin', '3')
+      ->save();
+
+    // Create 3 terms.
+    for ($x = 1; $x <= 3; $x++) {
+      $this->createTerm($this->vocabulary);
+    }
+
+    // Get Page 1.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/overview');
+    $this->assertNoPattern('|<nav class="pager" [^>]*>|', 'Pager is not visible on page 1');
+
+    // Create 3 more terms to show pager.
+    for ($x = 1; $x <= 3; $x++) {
+      $this->createTerm($this->vocabulary);
+    }
+
+    // Get Page 1.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/overview');
+    $this->assertPattern('|<nav class="pager" [^>]*>|', 'Pager is visible on page 1');
+
+    // Get Page 2.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/overview', ['query' => ['page' => 1]]);
+    $this->assertPattern('|<nav class="pager" [^>]*>|', 'Pager is visible on page 2');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TaxonomyTestBase.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\field\Tests\EntityReference\EntityReferenceTestTrait;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Provides common helper methods for Taxonomy module tests.
+ */
+abstract class TaxonomyTestBase extends BrowserTestBase {
+
+  use TaxonomyTestTrait;
+  use EntityReferenceTestTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'block'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalPlaceBlock('system_breadcrumb_block');
+
+    // Create Basic page and Article node types.
+    if ($this->profile != 'standard') {
+      $this->drupalCreateContentType(['type' => 'article', 'name' => 'Article']);
+    }
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TaxonomyTestTrait.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\taxonomy\Entity\Term;
+
+/**
+ * Provides common helper methods for Taxonomy module tests.
+ */
+trait TaxonomyTestTrait {
+
+  /**
+   * Returns a new vocabulary with random properties.
+   */
+  public function createVocabulary() {
+    // Create a vocabulary.
+    $vocabulary = Vocabulary::create([
+      'name' => $this->randomMachineName(),
+      'description' => $this->randomMachineName(),
+      'vid' => Unicode::strtolower($this->randomMachineName()),
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+      'weight' => mt_rand(0, 10),
+    ]);
+    $vocabulary->save();
+    return $vocabulary;
+  }
+
+  /**
+   * Returns a new term with random properties in vocabulary $vid.
+   *
+   * @param \Drupal\taxonomy\Entity\Vocabulary $vocabulary
+   *   The vocabulary object.
+   * @param array $values
+   *   (optional) An array of values to set, keyed by property name. If the
+   *   entity type has bundles, the bundle key has to be specified.
+   *
+   * @return \Drupal\taxonomy\Entity\Term
+   *   The new taxonomy term object.
+   */
+  public function createTerm(Vocabulary $vocabulary, $values = []) {
+    $filter_formats = filter_formats();
+    $format = array_pop($filter_formats);
+    $term = Term::create($values + [
+      'name' => $this->randomMachineName(),
+      'description' => [
+        'value' => $this->randomMachineName(),
+        // Use the first available text format.
+        'format' => $format->id(),
+      ],
+      'vid' => $vocabulary->id(),
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+    ]);
+    $term->save();
+    return $term;
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TaxonomyTranslationTestTrait.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\field\Tests\EntityReference\EntityReferenceTestTrait;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\language\Entity\ConfigurableLanguage;
+
+/**
+ * Provides common testing base for translated taxonomy terms.
+ */
+trait TaxonomyTranslationTestTrait {
+
+  use EntityReferenceTestTrait;
+
+  /**
+   * The vocabulary.
+   *
+   * @var \Drupal\taxonomy\Entity\Vocabulary;
+   */
+  protected $vocabulary;
+
+  /**
+   * The field name for our taxonomy term field.
+   *
+   * @var string
+   */
+  protected $termFieldName = 'field_tag';
+
+  /**
+   * The langcode of the source language.
+   *
+   * @var string
+   */
+  protected $baseLangcode = 'en';
+
+  /**
+   * Target langcode for translation.
+   *
+   * @var string
+   */
+  protected $translateToLangcode = 'hu';
+
+  /**
+   * The node to check the translated value on.
+   *
+   * @var \Drupal\node\Entity\Node
+   */
+  protected $node;
+
+  /**
+   * Adds additional languages.
+   */
+  protected function setupLanguages() {
+    ConfigurableLanguage::createFromLangcode($this->translateToLangcode)->save();
+    $this->rebuildContainer();
+  }
+
+  /**
+   * Enables translations where it needed.
+   */
+  protected function enableTranslation() {
+    // Enable translation for the current entity type and ensure the change is
+    // picked up.
+    \Drupal::service('content_translation.manager')->setEnabled('node', 'article', TRUE);
+    \Drupal::service('content_translation.manager')->setEnabled('taxonomy_term', $this->vocabulary->id(), TRUE);
+    drupal_static_reset();
+    \Drupal::entityManager()->clearCachedDefinitions();
+    \Drupal::service('router.builder')->rebuild();
+    \Drupal::service('entity.definition_update_manager')->applyUpdates();
+  }
+
+  /**
+   * Adds term reference field for the article content type.
+   *
+   * @param bool $translatable
+   *   (optional) If TRUE, create a translatable term reference field. Defaults
+   *   to FALSE.
+   */
+  protected function setUpTermReferenceField() {
+    $handler_settings = [
+      'target_bundles' => [
+        $this->vocabulary->id() => $this->vocabulary->id(),
+      ],
+      'auto_create' => TRUE,
+    ];
+    $this->createEntityReferenceField('node', 'article', $this->termFieldName, NULL, 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+    $field_storage = FieldStorageConfig::loadByName('node', $this->termFieldName);
+    $field_storage->setTranslatable(FALSE);
+    $field_storage->save();
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($this->termFieldName, [
+        'type' => 'entity_reference_autocomplete_tags',
+      ])
+      ->save();
+    entity_get_display('node', 'article', 'default')
+      ->setComponent($this->termFieldName, [
+        'type' => 'entity_reference_label',
+      ])
+      ->save();
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TermCacheTagsTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\system\Tests\Entity\EntityWithUriCacheTagsTestBase;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\taxonomy\Entity\Term;
+
+/**
+ * Tests the Taxonomy term entity's cache tags.
+ *
+ * @group taxonomy
+ */
+class TermCacheTagsTest extends EntityWithUriCacheTagsTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function createEntity() {
+    // Create a "Camelids" vocabulary.
+    $vocabulary = Vocabulary::create([
+      'name' => 'Camelids',
+      'vid' => 'camelids',
+    ]);
+    $vocabulary->save();
+
+    // Create a "Llama" taxonomy term.
+    $term = Term::create([
+      'name' => 'Llama',
+      'vid' => $vocabulary->id(),
+    ]);
+    $term->save();
+
+    return $term;
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TermEntityReferenceTest.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\field\Entity\FieldConfig;
+
+/**
+ * Tests the settings of restricting term selection to a single vocabulary.
+ *
+ * @group taxonomy
+ */
+class TermEntityReferenceTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['entity_reference_test', 'entity_test'];
+
+  /**
+   * Tests an entity reference field restricted to a single vocabulary.
+   *
+   * Creates two vocabularies with a term, then set up the entity reference
+   * field to limit the target vocabulary to one of them, ensuring that
+   * the restriction applies.
+   */
+  public function testSelectionTestVocabularyRestriction() {
+
+    // Create two vocabularies.
+    $vocabulary = $this->createVocabulary();
+    $vocabulary2 = $this->createVocabulary();
+
+    $term = $this->createTerm($vocabulary);
+    $term2 = $this->createTerm($vocabulary2);
+
+    // Create an entity reference field.
+    $field_name = 'taxonomy_' . $vocabulary->id();
+    $field_storage = FieldStorageConfig::create([
+      'field_name' => $field_name,
+      'entity_type' => 'entity_test',
+      'translatable' => FALSE,
+      'settings' => [
+        'target_type' => 'taxonomy_term',
+      ],
+      'type' => 'entity_reference',
+      'cardinality' => 1,
+    ]);
+    $field_storage->save();
+    $field = FieldConfig::create([
+      'field_storage' => $field_storage,
+      'entity_type' => 'entity_test',
+      'bundle' => 'test_bundle',
+      'settings' => [
+        'handler' => 'default',
+        'handler_settings' => [
+          // Restrict selection of terms to a single vocabulary.
+          'target_bundles' => [
+            $vocabulary->id() => $vocabulary->id(),
+          ],
+        ],
+      ],
+    ]);
+    $field->save();
+
+    $handler = $this->container->get('plugin.manager.entity_reference_selection')->getSelectionHandler($field);
+    $result = $handler->getReferenceableEntities();
+
+    $expected_result = [
+      $vocabulary->id() => [
+        $term->id() => $term->getName(),
+      ],
+    ];
+
+    $this->assertIdentical($result, $expected_result, 'Terms selection restricted to a single vocabulary.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TermIndexTest.php

@@ -0,0 +1,214 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+
+/**
+ * Tests the hook implementations that maintain the taxonomy index.
+ *
+ * @group taxonomy
+ */
+class TermIndexTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['views'];
+
+  /**
+   * Vocabulary for testing.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * Name of the taxonomy term reference field.
+   *
+   * @var string
+   */
+  protected $fieldName1;
+
+  /**
+   * Name of the taxonomy term reference field.
+   *
+   * @var string
+   */
+  protected $fieldName2;
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Create an administrative user.
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy', 'bypass node access']));
+
+    // Create a vocabulary and add two term reference fields to article nodes.
+    $this->vocabulary = $this->createVocabulary();
+
+    $this->fieldName1 = Unicode::strtolower($this->randomMachineName());
+    $handler_settings = [
+      'target_bundles' => [
+        $this->vocabulary->id() => $this->vocabulary->id(),
+       ],
+      'auto_create' => TRUE,
+    ];
+    $this->createEntityReferenceField('node', 'article', $this->fieldName1, NULL, 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($this->fieldName1, [
+        'type' => 'options_select',
+      ])
+      ->save();
+    entity_get_display('node', 'article', 'default')
+      ->setComponent($this->fieldName1, [
+        'type' => 'entity_reference_label',
+      ])
+      ->save();
+
+    $this->fieldName2 = Unicode::strtolower($this->randomMachineName());
+    $this->createEntityReferenceField('node', 'article', $this->fieldName2, NULL, 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($this->fieldName2, [
+        'type' => 'options_select',
+      ])
+      ->save();
+    entity_get_display('node', 'article', 'default')
+      ->setComponent($this->fieldName2, [
+        'type' => 'entity_reference_label',
+      ])
+      ->save();
+  }
+
+  /**
+   * Tests that the taxonomy index is maintained properly.
+   */
+  public function testTaxonomyIndex() {
+    $node_storage = $this->container->get('entity.manager')->getStorage('node');
+    // Create terms in the vocabulary.
+    $term_1 = $this->createTerm($this->vocabulary);
+    $term_2 = $this->createTerm($this->vocabulary);
+
+    // Post an article.
+    $edit = [];
+    $edit['title[0][value]'] = $this->randomMachineName();
+    $edit['body[0][value]'] = $this->randomMachineName();
+    $edit["{$this->fieldName1}[]"] = $term_1->id();
+    $edit["{$this->fieldName2}[]"] = $term_1->id();
+    $this->drupalPostForm('node/add/article', $edit, t('Save'));
+
+    // Check that the term is indexed, and only once.
+    $node = $this->drupalGetNodeByTitle($edit['title[0][value]']);
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_1->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 1 is indexed once.');
+
+    // Update the article to change one term.
+    $edit["{$this->fieldName1}[]"] = $term_2->id();
+    $this->drupalPostForm('node/' . $node->id() . '/edit', $edit, t('Save'));
+
+    // Check that both terms are indexed.
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_1->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 1 is indexed.');
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_2->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 2 is indexed.');
+
+    // Update the article to change another term.
+    $edit["{$this->fieldName2}[]"] = $term_2->id();
+    $this->drupalPostForm('node/' . $node->id() . '/edit', $edit, t('Save'));
+
+    // Check that only one term is indexed.
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_1->id(),
+    ])->fetchField();
+    $this->assertEqual(0, $index_count, 'Term 1 is not indexed.');
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_2->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 2 is indexed once.');
+
+    // Redo the above tests without interface.
+    $node_storage->resetCache([$node->id()]);
+    $node = $node_storage->load($node->id());
+    $node->title = $this->randomMachineName();
+
+    // Update the article with no term changed.
+    $node->save();
+
+    // Check that the index was not changed.
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_1->id(),
+    ])->fetchField();
+    $this->assertEqual(0, $index_count, 'Term 1 is not indexed.');
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_2->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 2 is indexed once.');
+
+    // Update the article to change one term.
+    $node->{$this->fieldName1} = [['target_id' => $term_1->id()]];
+    $node->save();
+
+    // Check that both terms are indexed.
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_1->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 1 is indexed.');
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_2->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 2 is indexed.');
+
+    // Update the article to change another term.
+    $node->{$this->fieldName2} = [['target_id' => $term_1->id()]];
+    $node->save();
+
+    // Check that only one term is indexed.
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_1->id(),
+    ])->fetchField();
+    $this->assertEqual(1, $index_count, 'Term 1 is indexed once.');
+    $index_count = db_query('SELECT COUNT(*) FROM {taxonomy_index} WHERE nid = :nid AND tid = :tid', [
+      ':nid' => $node->id(),
+      ':tid' => $term_2->id(),
+    ])->fetchField();
+    $this->assertEqual(0, $index_count, 'Term 2 is not indexed.');
+  }
+
+  /**
+   * Tests that there is a link to the parent term on the child term page.
+   */
+  public function testTaxonomyTermHierarchyBreadcrumbs() {
+    // Create two taxonomy terms and set term2 as the parent of term1.
+    $term1 = $this->createTerm($this->vocabulary);
+    $term2 = $this->createTerm($this->vocabulary);
+    $term1->parent = [$term2->id()];
+    $term1->save();
+
+    // Verify that the page breadcrumbs include a link to the parent term.
+    $this->drupalGet('taxonomy/term/' . $term1->id());
+    // Breadcrumbs are not rendered with a language, prevent the term
+    // language from being added to the options.
+    $this->assertRaw(\Drupal::l($term2->getName(), $term2->urlInfo('canonical', ['language' => NULL])), 'Parent term link is displayed when viewing the node.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TermLanguageTest.php

@@ -0,0 +1,143 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\language\Entity\ConfigurableLanguage;
+
+/**
+ * Tests the language functionality for the taxonomy terms.
+ *
+ * @group taxonomy
+ */
+class TermLanguageTest extends TaxonomyTestBase {
+
+  public static $modules = ['language'];
+
+  /**
+   * Vocabulary for testing.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Create an administrative user.
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy']));
+
+    // Create a vocabulary to which the terms will be assigned.
+    $this->vocabulary = $this->createVocabulary();
+
+    // Add some custom languages.
+    foreach (['aa', 'bb', 'cc'] as $language_code) {
+      ConfigurableLanguage::create([
+        'id' => $language_code,
+        'label' => $this->randomMachineName(),
+      ])->save();
+    }
+  }
+
+  public function testTermLanguage() {
+    // Configure the vocabulary to not hide the language selector.
+    $edit = [
+      'default_language[language_alterable]' => TRUE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $this->vocabulary->id(), $edit, t('Save'));
+
+    // Add a term.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add');
+    // Check that we have the language selector.
+    $this->assertField('edit-langcode-0-value', t('The language selector field was found on the page.'));
+    // Submit the term.
+    $edit = [
+      'name[0][value]' => $this->randomMachineName(),
+      'langcode[0][value]' => 'aa',
+    ];
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $terms = taxonomy_term_load_multiple_by_name($edit['name[0][value]']);
+    $term = reset($terms);
+    $this->assertEqual($term->language()->getId(), $edit['langcode[0][value]'], 'The term contains the correct langcode.');
+
+    // Check if on the edit page the language is correct.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertOptionSelected('edit-langcode-0-value', $edit['langcode[0][value]'], 'The term language was correctly selected.');
+
+    // Change the language of the term.
+    $edit['langcode[0][value]'] = 'bb';
+    $this->drupalPostForm('taxonomy/term/' . $term->id() . '/edit', $edit, t('Save'));
+
+    // Check again that on the edit page the language is correct.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertOptionSelected('edit-langcode-0-value', $edit['langcode[0][value]'], 'The term language was correctly selected.');
+  }
+
+  public function testDefaultTermLanguage() {
+    // Configure the vocabulary to not hide the language selector, and make the
+    // default language of the terms fixed.
+    $edit = [
+      'default_language[langcode]' => 'bb',
+      'default_language[language_alterable]' => TRUE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $this->vocabulary->id(), $edit, t('Save'));
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add');
+    $this->assertOptionSelected('edit-langcode-0-value', 'bb', 'The expected langcode was selected.');
+
+    // Make the default language of the terms to be the current interface.
+    $edit = [
+      'default_language[langcode]' => 'current_interface',
+      'default_language[language_alterable]' => TRUE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $this->vocabulary->id(), $edit, t('Save'));
+    $this->drupalGet('aa/admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add');
+    $this->assertOptionSelected('edit-langcode-0-value', 'aa', "The expected langcode, 'aa', was selected.");
+    $this->drupalGet('bb/admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add');
+    $this->assertOptionSelected('edit-langcode-0-value', 'bb', "The expected langcode, 'bb', was selected.");
+
+    // Change the default language of the site and check if the default terms
+    // language is still correctly selected.
+    $this->config('system.site')->set('default_langcode', 'cc')->save();
+    $edit = [
+      'default_language[langcode]' => LanguageInterface::LANGCODE_SITE_DEFAULT,
+      'default_language[language_alterable]' => TRUE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $this->vocabulary->id(), $edit, t('Save'));
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add');
+    $this->assertOptionSelected('edit-langcode-0-value', 'cc', "The expected langcode, 'cc', was selected.");
+  }
+
+  /**
+   * Tests that translated terms are displayed correctly on the term overview.
+   */
+  public function testTermTranslatedOnOverviewPage() {
+    // Configure the vocabulary to not hide the language selector.
+    $edit = [
+      'default_language[language_alterable]' => TRUE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $this->vocabulary->id(), $edit, t('Save'));
+
+    // Add a term.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/add');
+    // Submit the term.
+    $edit = [
+      'name[0][value]' => $this->randomMachineName(),
+      'langcode[0][value]' => 'aa',
+    ];
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $terms = taxonomy_term_load_multiple_by_name($edit['name[0][value]']);
+    $term = reset($terms);
+
+    // Add a translation for that term.
+    $translated_title = $this->randomMachineName();
+    $term->addTranslation('bb', [
+      'name' => $translated_title,
+    ]);
+    $term->save();
+
+    // Overview page in the other language shows the translated term
+    $this->drupalGet('bb/admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/overview');
+    $this->assertPattern('|<a[^>]*>' . $translated_title . '</a>|', 'The term language is correct');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TermTranslationFieldViewTest.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\node\Entity\Node;
+
+/**
+ * Tests the translation of taxonomy terms field on nodes.
+ *
+ * @group taxonomy
+ */
+class TermTranslationFieldViewTest extends TaxonomyTestBase {
+
+  use TaxonomyTranslationTestTrait;
+
+  /**
+   * The term that should be translated.
+   *
+   * @var \Drupal\taxonomy\Entity\Term
+   */
+  protected $term;
+
+  /**
+   * The tag in the source language.
+   *
+   * @var string
+   */
+  protected $baseTagName = 'OriginalTagName';
+
+  /**
+   * The translated value for the tag.
+   *
+   * @var string
+   */
+  protected $translatedTagName = 'TranslatedTagName';
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['language', 'content_translation', 'taxonomy'];
+
+  protected function setUp() {
+    parent::setUp();
+    $this->setupLanguages();
+    $this->vocabulary = $this->createVocabulary();
+    $this->enableTranslation();
+    $this->setUpTerm();
+    $this->setUpTermReferenceField();
+    $this->setUpNode();
+  }
+
+  /**
+   * Tests if the translated taxonomy term is displayed.
+   */
+  public function testTranslatedTaxonomyTermReferenceDisplay() {
+    $path = 'node/' . $this->node->id();
+    $translation_path = $this->translateToLangcode . '/' . $path;
+
+    $this->drupalGet($path);
+    $this->assertNoText($this->translatedTagName);
+    $this->assertText($this->baseTagName);
+    $this->drupalGet($translation_path);
+    $this->assertText($this->translatedTagName);
+    $this->assertNoText($this->baseTagName);
+  }
+
+  /**
+   * Creates a test subject node, with translation.
+   */
+  protected function setUpNode() {
+    /** @var \Drupal\node\Entity\Node $node */
+    $node = Node::create([
+      'title' => $this->randomMachineName(),
+      'type' => 'article',
+      'description' => [[
+        'value' => $this->randomMachineName(),
+        'format' => 'basic_html'
+      ]],
+      $this->termFieldName => [['target_id' => $this->term->id()]],
+      'langcode' => $this->baseLangcode,
+    ]);
+    $node->save();
+    $node->addTranslation($this->translateToLangcode, $node->toArray());
+    $node->save();
+    $this->node = $node;
+  }
+
+  /**
+   * Creates a test subject term, with translation.
+   */
+  protected function setUpTerm() {
+    $this->term = $this->createTerm($this->vocabulary, [
+      'name' => $this->baseTagName,
+      'langcode' => $this->baseLangcode,
+    ]);
+
+    $this->term->addTranslation($this->translateToLangcode, [
+      'name' => $this->translatedTagName,
+    ]);
+    $this->term->save();
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TermTranslationUITest.php

@@ -0,0 +1,164 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Tests\content_translation\Functional\ContentTranslationUITestBase;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Tests the Term Translation UI.
+ *
+ * @group taxonomy
+ */
+class TermTranslationUITest extends ContentTranslationUITestBase {
+
+  /**
+   * The vocabulary used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['language', 'content_translation', 'taxonomy'];
+
+  protected function setUp() {
+    $this->entityTypeId = 'taxonomy_term';
+    $this->bundle = 'tags';
+    parent::setUp();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setupBundle() {
+    parent::setupBundle();
+
+    // Create a vocabulary.
+    $this->vocabulary = Vocabulary::create([
+      'name' => $this->bundle,
+      'description' => $this->randomMachineName(),
+      'vid' => $this->bundle,
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+      'weight' => mt_rand(0, 10),
+    ]);
+    $this->vocabulary->save();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getTranslatorPermissions() {
+    return array_merge(parent::getTranslatorPermissions(), ['administer taxonomy']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNewEntityValues($langcode) {
+    return ['name' => $this->randomMachineName()] + parent::getNewEntityValues($langcode);
+  }
+
+  /**
+   * Returns an edit array containing the values to be posted.
+   */
+  protected function getEditValues($values, $langcode, $new = FALSE) {
+    $edit = parent::getEditValues($values, $langcode, $new);
+
+    // To be able to post values for the configurable base fields (name,
+    // description) have to be suffixed with [0][value].
+    foreach ($edit as $property => $value) {
+      foreach (['name', 'description'] as $key) {
+        if ($property == $key) {
+          $edit[$key . '[0][value]'] = $value;
+          unset($edit[$property]);
+        }
+      }
+    }
+    return $edit;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testTranslationUI() {
+    parent::testTranslationUI();
+
+    // Make sure that no row was inserted for taxonomy vocabularies which do
+    // not have translations enabled.
+    $rows = db_query('SELECT tid, count(tid) AS count FROM {taxonomy_term_field_data} WHERE vid <> :vid GROUP BY tid', [':vid' => $this->bundle])->fetchAll();
+    foreach ($rows as $row) {
+      $this->assertTrue($row->count < 2, 'Term does not have translations.');
+    }
+  }
+
+  /**
+   * Tests translate link on vocabulary term list.
+   */
+  public function testTranslateLinkVocabularyAdminPage() {
+    $this->drupalLogin($this->drupalCreateUser(array_merge(parent::getTranslatorPermissions(), ['access administration pages', 'administer taxonomy'])));
+
+    $values = [
+      'name' => $this->randomMachineName(),
+    ];
+    $translatable_tid = $this->createEntity($values, $this->langcodes[0], $this->vocabulary->id());
+
+    // Create an untranslatable vocabulary.
+    $untranslatable_vocabulary = Vocabulary::create([
+      'name' => 'untranslatable_voc',
+      'description' => $this->randomMachineName(),
+      'vid' => 'untranslatable_voc',
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+      'weight' => mt_rand(0, 10),
+    ]);
+    $untranslatable_vocabulary->save();
+
+    $values = [
+      'name' => $this->randomMachineName(),
+    ];
+    $untranslatable_tid = $this->createEntity($values, $this->langcodes[0], $untranslatable_vocabulary->id());
+
+    // Verify translation links.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $this->vocabulary->id() . '/overview');
+    $this->assertResponse(200, 'The translatable vocabulary page was found.');
+    $this->assertLinkByHref('term/' . $translatable_tid . '/translations', 0, 'The translations link exists for a translatable vocabulary.');
+    $this->assertLinkByHref('term/' . $translatable_tid . '/edit', 0, 'The edit link exists for a translatable vocabulary.');
+
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $untranslatable_vocabulary->id() . '/overview');
+    $this->assertResponse(200);
+    $this->assertLinkByHref('term/' . $untranslatable_tid . '/edit');
+    $this->assertNoLinkByHref('term/' . $untranslatable_tid . '/translations');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function doTestTranslationEdit() {
+    $storage = $this->container->get('entity_type.manager')
+      ->getStorage($this->entityTypeId);
+    $storage->resetCache([$this->entityId]);
+    $entity = $storage->load($this->entityId);
+    $languages = $this->container->get('language_manager')->getLanguages();
+
+    foreach ($this->langcodes as $langcode) {
+      // We only want to test the title for non-english translations.
+      if ($langcode != 'en') {
+        $options = ['language' => $languages[$langcode]];
+        $url = $entity->urlInfo('edit-form', $options);
+        $this->drupalGet($url);
+
+        $title = t('@title [%language translation]', [
+          '@title' => $entity->getTranslation($langcode)->label(),
+          '%language' => $languages[$langcode]->getName(),
+        ]);
+        $this->assertRaw($title);
+      }
+    }
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/ThemeTest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+/**
+ * Verifies that various taxonomy pages use the expected theme.
+ *
+ * @group taxonomy
+ */
+class ThemeTest extends TaxonomyTestBase {
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Make sure we are using distinct default and administrative themes for
+    // the duration of these tests.
+    \Drupal::service('theme_handler')->install(['bartik', 'seven']);
+    $this->config('system.theme')
+      ->set('default', 'bartik')
+      ->set('admin', 'seven')
+      ->save();
+
+    // Create and log in as a user who has permission to add and edit taxonomy
+    // terms and view the administrative theme.
+    $admin_user = $this->drupalCreateUser(['administer taxonomy', 'view the administration theme']);
+    $this->drupalLogin($admin_user);
+  }
+
+  /**
+   * Test the theme used when adding, viewing and editing taxonomy terms.
+   */
+  public function testTaxonomyTermThemes() {
+    // Adding a term to a vocabulary is considered an administrative action and
+    // should use the administrative theme.
+    $vocabulary = $this->createVocabulary();
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vocabulary->id() . '/add');
+    $this->assertRaw('seven/css/base/elements.css', t("The administrative theme's CSS appears on the page for adding a taxonomy term."));
+
+    // Viewing a taxonomy term should use the default theme.
+    $term = $this->createTerm($vocabulary);
+    $this->drupalGet('taxonomy/term/' . $term->id());
+    $this->assertRaw('bartik/css/base/elements.css', t("The default theme's CSS appears on the page for viewing a taxonomy term."));
+
+    // Editing a taxonomy term should use the same theme as adding one.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertRaw('seven/css/base/elements.css', t("The administrative theme's CSS appears on the page for editing a taxonomy term."));
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/TokenReplaceTest.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\Render\BubbleableMetadata;
+
+/**
+ * Generates text using placeholders for dummy content to check taxonomy token
+ * replacement.
+ *
+ * @group taxonomy
+ */
+class TokenReplaceTest extends TaxonomyTestBase {
+
+  /**
+   * The vocabulary used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * Name of the taxonomy term reference field.
+   *
+   * @var string
+   */
+  protected $fieldName;
+
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy', 'bypass node access']));
+    $this->vocabulary = $this->createVocabulary();
+    $this->fieldName = 'taxonomy_' . $this->vocabulary->id();
+
+    $handler_settings = [
+      'target_bundles' => [
+        $this->vocabulary->id() => $this->vocabulary->id(),
+      ],
+      'auto_create' => TRUE,
+    ];
+    $this->createEntityReferenceField('node', 'article', $this->fieldName, NULL, 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($this->fieldName, [
+        'type' => 'options_select',
+      ])
+      ->save();
+    entity_get_display('node', 'article', 'default')
+      ->setComponent($this->fieldName, [
+        'type' => 'entity_reference_label',
+      ])
+      ->save();
+  }
+
+  /**
+   * Creates some terms and a node, then tests the tokens generated from them.
+   */
+  public function testTaxonomyTokenReplacement() {
+    $token_service = \Drupal::token();
+    $language_interface = \Drupal::languageManager()->getCurrentLanguage();
+
+    // Create two taxonomy terms.
+    $term1 = $this->createTerm($this->vocabulary);
+    $term2 = $this->createTerm($this->vocabulary);
+
+    // Edit $term2, setting $term1 as parent.
+    $edit = [];
+    $edit['name[0][value]'] = '<blink>Blinking Text</blink>';
+    $edit['parent[]'] = [$term1->id()];
+    $this->drupalPostForm('taxonomy/term/' . $term2->id() . '/edit', $edit, t('Save'));
+
+    // Create node with term2.
+    $edit = [];
+    $node = $this->drupalCreateNode(['type' => 'article']);
+    $edit[$this->fieldName . '[]'] = $term2->id();
+    $this->drupalPostForm('node/' . $node->id() . '/edit', $edit, t('Save'));
+
+    // Generate and test sanitized tokens for term1.
+    $tests = [];
+    $tests['[term:tid]'] = $term1->id();
+    $tests['[term:name]'] = $term1->getName();
+    $tests['[term:description]'] = $term1->description->processed;
+    $tests['[term:url]'] = $term1->url('canonical', ['absolute' => TRUE]);
+    $tests['[term:node-count]'] = 0;
+    $tests['[term:parent:name]'] = '[term:parent:name]';
+    $tests['[term:vocabulary:name]'] = $this->vocabulary->label();
+    $tests['[term:vocabulary]'] = $this->vocabulary->label();
+
+    $base_bubbleable_metadata = BubbleableMetadata::createFromObject($term1);
+
+    $metadata_tests = [];
+    $metadata_tests['[term:tid]'] = $base_bubbleable_metadata;
+    $metadata_tests['[term:name]'] = $base_bubbleable_metadata;
+    $metadata_tests['[term:description]'] = $base_bubbleable_metadata;
+    $metadata_tests['[term:url]'] = $base_bubbleable_metadata;
+    $metadata_tests['[term:node-count]'] = $base_bubbleable_metadata;
+    $metadata_tests['[term:parent:name]'] = $base_bubbleable_metadata;
+    $bubbleable_metadata = clone $base_bubbleable_metadata;
+    $metadata_tests['[term:vocabulary:name]'] = $bubbleable_metadata->addCacheTags($this->vocabulary->getCacheTags());
+    $metadata_tests['[term:vocabulary]'] = $bubbleable_metadata->addCacheTags($this->vocabulary->getCacheTags());
+
+    foreach ($tests as $input => $expected) {
+      $bubbleable_metadata = new BubbleableMetadata();
+      $output = $token_service->replace($input, ['term' => $term1], ['langcode' => $language_interface->getId()], $bubbleable_metadata);
+      $this->assertEqual($output, $expected, format_string('Sanitized taxonomy term token %token replaced.', ['%token' => $input]));
+      $this->assertEqual($bubbleable_metadata, $metadata_tests[$input]);
+    }
+
+    // Generate and test sanitized tokens for term2.
+    $tests = [];
+    $tests['[term:tid]'] = $term2->id();
+    $tests['[term:name]'] = $term2->getName();
+    $tests['[term:description]'] = $term2->description->processed;
+    $tests['[term:url]'] = $term2->url('canonical', ['absolute' => TRUE]);
+    $tests['[term:node-count]'] = 1;
+    $tests['[term:parent:name]'] = $term1->getName();
+    $tests['[term:parent:url]'] = $term1->url('canonical', ['absolute' => TRUE]);
+    $tests['[term:parent:parent:name]'] = '[term:parent:parent:name]';
+    $tests['[term:vocabulary:name]'] = $this->vocabulary->label();
+
+    // Test to make sure that we generated something for each token.
+    $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
+
+    foreach ($tests as $input => $expected) {
+      $output = $token_service->replace($input, ['term' => $term2], ['langcode' => $language_interface->getId()]);
+      $this->assertEqual($output, $expected, format_string('Sanitized taxonomy term token %token replaced.', ['%token' => $input]));
+    }
+
+    // Generate and test sanitized tokens.
+    $tests = [];
+    $tests['[vocabulary:vid]'] = $this->vocabulary->id();
+    $tests['[vocabulary:name]'] = $this->vocabulary->label();
+    $tests['[vocabulary:description]'] = $this->vocabulary->getDescription();
+    $tests['[vocabulary:node-count]'] = 1;
+    $tests['[vocabulary:term-count]'] = 2;
+
+    // Test to make sure that we generated something for each token.
+    $this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
+
+    foreach ($tests as $input => $expected) {
+      $output = $token_service->replace($input, ['vocabulary' => $this->vocabulary], ['langcode' => $language_interface->getId()]);
+      $this->assertEqual($output, $expected, format_string('Sanitized taxonomy vocabulary token %token replaced.', ['%token' => $input]));
+    }
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/ArgumentValidatorTermTest.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Views;
+
+/**
+ * Tests the plugin of the taxonomy: term argument validator.
+ *
+ * @group taxonomy
+ * @see Views\taxonomy\Plugin\views\argument_validator\Term
+ */
+class ArgumentValidatorTermTest extends TaxonomyTestBase {
+
+  /**
+   * Stores the taxonomy term used by this test.
+   *
+   * @var array
+   */
+  protected $terms = [];
+
+  /**
+   * Stores the taxonomy names used by this test.
+   *
+   * @var array
+   */
+  protected $names = [];
+
+  /**
+   * Stores the taxonomy IDs used by this test.
+   *
+   * @var array
+   */
+  protected $ids = [];
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views', 'views_test_config'];
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_argument_validator_term'];
+
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Add three terms to the 'tags' vocabulary.
+    for ($i = 0; $i < 3; $i++) {
+      $this->terms[] = $term = $this->createTerm();
+      $this->names[] = $term->label();
+      $this->ids[] = $term->id();
+    }
+  }
+
+  /**
+   * Tests the term argument validator plugin.
+   */
+  public function testArgumentValidatorTerm() {
+    $view = Views::getView('test_argument_validator_term');
+    $view->initHandlers();
+
+
+    // Test the single validator for term IDs.
+    $view->argument['tid']->validator->options['type'] = 'tid';
+
+    // Pass in a single valid term.
+    foreach ($this->terms as $term) {
+      $this->assertTrue($view->argument['tid']->setArgument($term->id()));
+      $this->assertEqual($view->argument['tid']->getTitle(), $term->label());
+      $view->argument['tid']->validated_title = NULL;
+      $view->argument['tid']->argument_validated = NULL;
+    }
+
+    // Pass in a invalid term.
+    $this->assertFalse($view->argument['tid']->setArgument(rand(1000, 10000)));
+    $this->assertEqual('', $view->argument['tid']->getTitle());
+    $view->argument['tid']->validated_title = NULL;
+    $view->argument['tid']->argument_validated = NULL;
+
+
+    // Test the multiple validator for term IDs.
+    $view->argument['tid']->validator->options['type'] = 'tids';
+    $view->argument['tid']->options['break_phrase'] = TRUE;
+
+    // Pass in a single term.
+    $this->assertTrue($view->argument['tid']->setArgument($this->terms[0]->id()));
+    $this->assertEqual($view->argument['tid']->getTitle(), $this->terms[0]->label());
+    $view->argument['tid']->validated_title = NULL;
+    $view->argument['tid']->argument_validated = NULL;
+
+    // Check for multiple valid terms separated by commas.
+    $this->assertTrue($view->argument['tid']->setArgument(implode(',', $this->ids)));
+    $this->assertEqual($view->argument['tid']->getTitle(), implode(', ', $this->names));
+    $view->argument['tid']->validated_title = NULL;
+    $view->argument['tid']->argument_validated = NULL;
+
+    // Check for multiple valid terms separated by plus signs.
+    $this->assertTrue($view->argument['tid']->setArgument(implode('+', $this->ids)));
+    $this->assertEqual($view->argument['tid']->getTitle(), implode(' + ', $this->names));
+    $view->argument['tid']->validated_title = NULL;
+    $view->argument['tid']->argument_validated = NULL;
+
+    // Check for a single invalid term.
+    $this->assertFalse($view->argument['tid']->setArgument(rand(1000, 10000)));
+    $this->assertEqual('', $view->argument['tid']->getTitle());
+    $view->argument['tid']->validated_title = NULL;
+    $view->argument['tid']->argument_validated = NULL;
+
+    // Check for multiple invalid terms.
+    $this->assertFalse($view->argument['tid']->setArgument(implode(',', [rand(1000, 10000), rand(1000, 10000)])));
+    $this->assertEqual('', $view->argument['tid']->getTitle());
+    $view->argument['tid']->validated_title = NULL;
+    $view->argument['tid']->argument_validated = NULL;
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/RelationshipNodeTermDataTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Views;
+
+/**
+ * Tests the taxonomy term on node relationship handler.
+ *
+ * @group taxonomy
+ */
+class RelationshipNodeTermDataTest extends TaxonomyTestBase {
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_taxonomy_node_term_data'];
+
+  public function testViewsHandlerRelationshipNodeTermData() {
+    $view = Views::getView('test_taxonomy_node_term_data');
+    // Tests \Drupal\taxonomy\Plugin\views\relationship\NodeTermData::calculateDependencies().
+    $expected = [
+      'config' => ['core.entity_view_mode.node.teaser'],
+      'module' => [
+        'node',
+        'taxonomy',
+        'user',
+      ],
+    ];
+    $this->assertIdentical($expected, $view->getDependencies());
+    $this->executeView($view, [$this->term1->id(), $this->term2->id()]);
+    $expected_result = [
+      [
+        'nid' => $this->nodes[1]->id(),
+      ],
+      [
+        'nid' => $this->nodes[0]->id(),
+      ],
+    ];
+    $column_map = ['nid' => 'nid'];
+    $this->assertIdenticalResultset($view, $expected_result, $column_map);
+
+    // Change the view to test relation limited by vocabulary.
+    $this->config('views.view.test_taxonomy_node_term_data')
+      ->set('display.default.display_options.relationships.term_node_tid.vids', ['views_testing_tags'])
+      ->save();
+
+    $view = Views::getView('test_taxonomy_node_term_data');
+    // Tests \Drupal\taxonomy\Plugin\views\relationship\NodeTermData::calculateDependencies().
+    $expected['config'][] = 'taxonomy.vocabulary.views_testing_tags';
+    $this->assertIdentical($expected, $view->getDependencies());
+    $this->executeView($view, [$this->term1->id(), $this->term2->id()]);
+    $this->assertIdenticalResultset($view, $expected_result, $column_map);
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/RelationshipRepresentativeNodeTest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Views;
+
+/**
+ * Tests the representative node relationship for terms.
+ *
+ * @group taxonomy
+ */
+class RelationshipRepresentativeNodeTest extends TaxonomyTestBase {
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_groupwise_term'];
+
+  /**
+   * Tests the relationship.
+   */
+  public function testRelationship() {
+    $view = Views::getView('test_groupwise_term');
+    $this->executeView($view);
+    $map = ['node_field_data_taxonomy_term_field_data_nid' => 'nid', 'tid' => 'tid'];
+    $expected_result = [
+      [
+        'nid' => $this->nodes[1]->id(),
+        'tid' => $this->term2->id(),
+      ],
+      [
+        'nid' => $this->nodes[1]->id(),
+        'tid' => $this->term1->id(),
+      ],
+    ];
+    $this->assertIdenticalResultset($view, $expected_result, $map);
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyDefaultArgumentTest.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\field\Entity\FieldConfig;
+use Drupal\views\Views;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+
+/**
+ * Tests the representative node relationship for terms.
+ *
+ * @group taxonomy
+ */
+class TaxonomyDefaultArgumentTest extends TaxonomyTestBase {
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['taxonomy_default_argument_test'];
+
+  /**
+   * Tests the relationship.
+   */
+  public function testNodePath() {
+    $view = Views::getView('taxonomy_default_argument_test');
+
+    $request = Request::create($this->nodes[0]->url());
+    $request->server->set('SCRIPT_NAME', $GLOBALS['base_path'] . 'index.php');
+    $request->server->set('SCRIPT_FILENAME', 'index.php');
+
+    $response = $this->container->get('http_kernel')
+      ->handle($request, HttpKernelInterface::SUB_REQUEST);
+    $view->setRequest($request);
+    $view->setResponse($response);
+
+    $view->initHandlers();
+    $expected = implode(',', [$this->term1->id(), $this->term2->id()]);
+    $this->assertEqual($expected, $view->argument['tid']->getDefaultArgument());
+    $view->destroy();
+  }
+
+  public function testNodePathWithViewSelection() {
+    // Change the term entity reference field to use a view as selection plugin.
+    \Drupal::service('module_installer')->install(['entity_reference_test']);
+
+    $field_name = 'field_' . $this->vocabulary->id();
+    $field = FieldConfig::loadByName('node', 'article', $field_name);
+    $field->setSetting('handler', 'views');
+    $field->setSetting('handler_settings', [
+      'view' => [
+        'view_name' => 'test_entity_reference',
+        'display_name' => 'entity_reference_1',
+      ],
+    ]);
+    $field->save();
+
+    $view = Views::getView('taxonomy_default_argument_test');
+
+    $request = Request::create($this->nodes[0]->url());
+    $request->server->set('SCRIPT_NAME', $GLOBALS['base_path'] . 'index.php');
+    $request->server->set('SCRIPT_FILENAME', 'index.php');
+
+    $response = $this->container->get('http_kernel')->handle($request, HttpKernelInterface::SUB_REQUEST);
+    $view->setRequest($request);
+    $view->setResponse($response);
+
+    $view->initHandlers();
+    $expected = implode(',', [$this->term1->id(), $this->term2->id()]);
+    $this->assertEqual($expected, $view->argument['tid']->getDefaultArgument());
+  }
+
+  public function testTermPath() {
+    $view = Views::getView('taxonomy_default_argument_test');
+
+    $request = Request::create($this->term1->url());
+    $request->server->set('SCRIPT_NAME', $GLOBALS['base_path'] . 'index.php');
+    $request->server->set('SCRIPT_FILENAME', 'index.php');
+
+    $response = $this->container->get('http_kernel')->handle($request, HttpKernelInterface::SUB_REQUEST);
+    $view->setRequest($request);
+    $view->setResponse($response);
+    $view->initHandlers();
+
+    $expected = $this->term1->id();
+    $this->assertEqual($expected, $view->argument['tid']->getDefaultArgument());
+  }
+
+  /**
+   * Tests escaping of page title when the taxonomy plugin provides it.
+   */
+  public function testTermTitleEscaping() {
+    $this->term1->setName('<em>Markup</em>')->save();
+    $this->drupalGet('taxonomy_default_argument_test/' . $this->term1->id());
+    $this->assertEscaped($this->term1->label());
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyFieldAllTermsTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Views;
+use Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Tests the "All terms" taxonomy term field handler.
+ *
+ * @group taxonomy
+ */
+class TaxonomyFieldAllTermsTest extends TaxonomyTestBase {
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['taxonomy_all_terms_test'];
+
+  /**
+   * Tests the "all terms" field handler.
+   */
+  public function testViewsHandlerAllTermsField() {
+    $this->term1->setName('<em>Markup</em>')->save();
+    $view = Views::getView('taxonomy_all_terms_test');
+    $this->executeView($view);
+    $this->drupalGet('taxonomy_all_terms_test');
+
+    $actual = $this->xpath('//a[@href="' . $this->term1->url() . '"]');
+    $this->assertEqual(count($actual), 2, 'Correct number of taxonomy term1 links');
+    $this->assertEqual($actual[0]->getText(), $this->term1->label());
+    $this->assertEqual($actual[1]->getText(), $this->term1->label());
+    $this->assertEscaped($this->term1->label());
+
+    $actual = $this->xpath('//a[@href="' . $this->term2->url() . '"]');
+    $this->assertEqual(count($actual), 2, 'Correct number of taxonomy term2 links');
+    $this->assertEqual($actual[0]->getText(), $this->term2->label());
+    $this->assertEqual($actual[1]->getText(), $this->term2->label());
+  }
+
+  /**
+   * Tests token replacement in the "all terms" field handler.
+   */
+  public function testViewsHandlerAllTermsWithTokens() {
+    $view = Views::getView('taxonomy_all_terms_test');
+    $this->drupalGet('taxonomy_all_terms_token_test');
+
+    // Term itself: {{ term_node_tid }}
+    $this->assertText('Term: ' . $this->term1->getName());
+
+    // The taxonomy term ID for the term: {{ term_node_tid__tid }}
+    $this->assertText('The taxonomy term ID for the term: ' . $this->term1->id());
+
+    // The taxonomy term name for the term: {{ term_node_tid__name }}
+    $this->assertText('The taxonomy term name for the term: ' . $this->term1->getName());
+
+    // The machine name for the vocabulary the term belongs to: {{ term_node_tid__vocabulary_vid }}
+    $this->assertText('The machine name for the vocabulary the term belongs to: ' . $this->term1->getVocabularyId());
+
+    // The name for the vocabulary the term belongs to: {{ term_node_tid__vocabulary }}
+    $vocabulary = Vocabulary::load($this->term1->bundle());
+    $this->assertText('The name for the vocabulary the term belongs to: ' . $vocabulary->label());
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyFieldFilterTest.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\language\Entity\ConfigurableLanguage;
+use Drupal\Tests\views\Functional\ViewTestBase;
+use Drupal\views\Tests\ViewTestData;
+use Drupal\views\Views;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\taxonomy\Entity\Term;
+
+/**
+ * Tests taxonomy field filters with translations.
+ *
+ * @group taxonomy
+ */
+class TaxonomyFieldFilterTest extends ViewTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['language', 'taxonomy', 'taxonomy_test_views', 'text', 'views', 'node'];
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_field_filters'];
+
+  /**
+   * The vocabulary used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * List of taxonomy term names by language.
+   *
+   * @var array
+   */
+  public $termNames = [];
+
+  public function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Add two new languages.
+    ConfigurableLanguage::createFromLangcode('fr')->save();
+    ConfigurableLanguage::createFromLangcode('es')->save();
+
+    // Set up term names.
+    $this->termNames = [
+      'en' => 'Food in Paris',
+      'es' => 'Comida en Paris',
+      'fr' => 'Nouriture en Paris',
+    ];
+
+    // Create a vocabulary.
+    $this->vocabulary = Vocabulary::create([
+      'name' => 'Views testing tags',
+      'vid' => 'views_testing_tags',
+    ]);
+    $this->vocabulary->save();
+
+    // Add a translatable field to the vocabulary.
+    $field = FieldStorageConfig::create([
+      'field_name' => 'field_foo',
+      'entity_type' => 'taxonomy_term',
+      'type' => 'text',
+    ]);
+    $field->save();
+    FieldConfig::create([
+      'field_name' => 'field_foo',
+      'entity_type' => 'taxonomy_term',
+      'label' => 'Foo',
+      'bundle' => 'views_testing_tags',
+    ])->save();
+
+    // Create term with translations.
+    $taxonomy = $this->createTermWithProperties(['name' => $this->termNames['en'], 'langcode' => 'en', 'description' => $this->termNames['en'], 'field_foo' => $this->termNames['en']]);
+    foreach (['es', 'fr'] as $langcode) {
+      $translation = $taxonomy->addTranslation($langcode, ['name' => $this->termNames[$langcode]]);
+      $translation->description->value = $this->termNames[$langcode];
+      $translation->field_foo->value = $this->termNames[$langcode];
+    }
+    $taxonomy->save();
+
+    Views::viewsData()->clear();
+
+    ViewTestData::createTestViews(get_class($this), ['taxonomy_test_views']);
+    $this->container->get('router.builder')->rebuild();
+  }
+
+  /**
+   * Tests description and term name filters.
+   */
+  public function testFilters() {
+    // Test the name filter page, which filters for name contains 'Comida'.
+    // Should show just the Spanish translation, once.
+    $this->assertPageCounts('test-name-filter', ['es' => 1, 'fr' => 0, 'en' => 0], 'Comida name filter');
+
+    // Test the description filter page, which filters for description contains
+    // 'Comida'. Should show just the Spanish translation, once.
+    $this->assertPageCounts('test-desc-filter', ['es' => 1, 'fr' => 0, 'en' => 0], 'Comida description filter');
+
+    // Test the field filter page, which filters for field_foo contains
+    // 'Comida'. Should show just the Spanish translation, once.
+    $this->assertPageCounts('test-field-filter', ['es' => 1, 'fr' => 0, 'en' => 0], 'Comida field filter');
+
+    // Test the name Paris filter page, which filters for name contains
+    // 'Paris'. Should show each translation once.
+    $this->assertPageCounts('test-name-paris', ['es' => 1, 'fr' => 1, 'en' => 1], 'Paris name filter');
+
+    // Test the description Paris page, which filters for description contains
+    // 'Paris'. Should show each translation, once.
+    $this->assertPageCounts('test-desc-paris', ['es' => 1, 'fr' => 1, 'en' => 1], 'Paris description filter');
+
+    // Test the field Paris filter page, which filters for field_foo contains
+    // 'Paris'. Should show each translation once.
+    $this->assertPageCounts('test-field-paris', ['es' => 1, 'fr' => 1, 'en' => 1], 'Paris field filter');
+
+  }
+
+  /**
+   * Asserts that the given taxonomy translation counts are correct.
+   *
+   * @param string $path
+   *   Path of the page to test.
+   * @param array $counts
+   *   Array whose keys are languages, and values are the number of times
+   *   that translation should be shown on the given page.
+   * @param string $message
+   *   Message suffix to display.
+   */
+  protected function assertPageCounts($path, $counts, $message) {
+    // Get the text of the page.
+    $this->drupalGet($path);
+    $text = $this->getTextContent();
+
+    // Check the counts. Note that the title and body are both shown on the
+    // page, and they are the same. So the title/body string should appear on
+    // the page twice as many times as the input count.
+    foreach ($counts as $langcode => $count) {
+      $this->assertEqual(substr_count($text, $this->termNames[$langcode]), 2 * $count, 'Translation ' . $langcode . ' has count ' . $count . ' with ' . $message);
+    }
+  }
+
+  /**
+   * Creates a taxonomy term with specified name and other properties.
+   *
+   * @param array $properties
+   *   Array of properties and field values to set.
+   *
+   * @return \Drupal\taxonomy\TermInterface
+   *   The created taxonomy term.
+   */
+  protected function createTermWithProperties($properties) {
+    // Use the first available text format.
+    $filter_formats = filter_formats();
+    $format = array_pop($filter_formats);
+
+    $properties += [
+      'name' => $this->randomMachineName(),
+      'description' => $this->randomMachineName(),
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+      'field_foo' => $this->randomMachineName(),
+    ];
+
+    $term = Term::create([
+      'name' => $properties['name'],
+      'description' => $properties['description'],
+      'format' => $format->id(),
+      'vid' => $this->vocabulary->id(),
+      'langcode' => $properties['langcode'],
+    ]);
+    $term->field_foo->value = $properties['field_foo'];
+    $term->save();
+    return $term;
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyFieldTidTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\Core\Render\RenderContext;
+use Drupal\views\Views;
+
+/**
+ * Tests the taxonomy term TID field handler.
+ *
+ * @group taxonomy
+ */
+class TaxonomyFieldTidTest extends TaxonomyTestBase {
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_taxonomy_tid_field'];
+
+  public function testViewsHandlerTidField() {
+    /** @var \Drupal\Core\Render\RendererInterface $renderer */
+    $renderer = \Drupal::service('renderer');
+
+    $view = Views::getView('test_taxonomy_tid_field');
+    $this->executeView($view);
+
+    $actual = $renderer->executeInRenderContext(new RenderContext(), function () use ($view) {
+      return $view->field['name']->advancedRender($view->result[0]);
+    });
+    $expected = \Drupal::l($this->term1->label(), $this->term1->urlInfo());
+
+    $this->assertEqual($expected, $actual);
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyIndexTidFilterTest.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\taxonomy\Entity\Term;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\views\Entity\View;
+use Drupal\views\Tests\ViewTestData;
+
+/**
+ * Test the taxonomy term index filter.
+ *
+ * @see \Drupal\taxonomy\Plugin\views\filter\TaxonomyIndexTid
+ *
+ * @group taxonomy
+ */
+class TaxonomyIndexTidFilterTest extends TaxonomyTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views', 'views', 'node'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $testViews = ['test_filter_taxonomy_index_tid__non_existing_dependency'];
+
+  /**
+   * @var \Drupal\taxonomy\TermInterface[]
+   */
+  protected $terms = [];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp(FALSE);
+
+    // Setup vocabulary and terms so the initial import is valid.
+    Vocabulary::create([
+      'vid' => 'tags',
+      'name' => 'Tags',
+    ])->save();
+
+    // This will get a term ID of 3.
+    $term = Term::create([
+      'vid' => 'tags',
+      'name' => 'muh',
+    ]);
+    $term->save();
+    // This will get a term ID of 4.
+    $this->terms[$term->id()] = $term;
+    $term = Term::create([
+      'vid' => 'tags',
+      'name' => 'muh',
+    ]);
+    $term->save();
+    $this->terms[$term->id()] = $term;
+
+    ViewTestData::createTestViews(get_class($this), ['taxonomy_test_views']);
+  }
+
+  /**
+   * Tests dependencies are not added for terms that do not exist.
+   */
+  public function testConfigDependency() {
+    /** @var \Drupal\views\Entity\View $view */
+    $view = View::load('test_filter_taxonomy_index_tid__non_existing_dependency');
+
+    // Dependencies are sorted.
+    $content_dependencies = [
+      $this->terms[3]->getConfigDependencyName(),
+      $this->terms[4]->getConfigDependencyName(),
+    ];
+    sort($content_dependencies);
+
+    $this->assertEqual([
+      'config' => [
+        'taxonomy.vocabulary.tags',
+      ],
+      'content' => $content_dependencies,
+      'module' => [
+        'node',
+        'taxonomy',
+        'user',
+      ],
+    ], $view->calculateDependencies()->getDependencies());
+
+    $this->terms[3]->delete();
+
+    $this->assertEqual([
+      'config' => [
+        'taxonomy.vocabulary.tags',
+      ],
+      'content' => [
+        $this->terms[4]->getConfigDependencyName(),
+      ],
+      'module' => [
+        'node',
+        'taxonomy',
+        'user',
+      ],
+    ], $view->calculateDependencies()->getDependencies());
+  }
+
+  /**
+   * Tests post update function fixes dependencies.
+   *
+   * @see views_post_update_taxonomy_index_tid()
+   */
+  public function testPostUpdateFunction() {
+    /** @var \Drupal\views\Entity\View $view */
+    $view = View::load('test_filter_taxonomy_index_tid__non_existing_dependency');
+
+    // Dependencies are sorted.
+    $content_dependencies = [
+      $this->terms[3]->getConfigDependencyName(),
+      $this->terms[4]->getConfigDependencyName(),
+    ];
+    sort($content_dependencies);
+
+    $this->assertEqual([
+      'config' => [
+        'taxonomy.vocabulary.tags',
+      ],
+      'content' => $content_dependencies,
+      'module' => [
+        'node',
+        'taxonomy',
+        'user',
+      ],
+    ], $view->calculateDependencies()->getDependencies());
+
+    $this->terms[3]->delete();
+
+    \Drupal::moduleHandler()->loadInclude('views', 'post_update.php');
+    views_post_update_taxonomy_index_tid();
+
+    $view = View::load('test_filter_taxonomy_index_tid__non_existing_dependency');
+    $this->assertEqual([
+      'config' => [
+        'taxonomy.vocabulary.tags',
+      ],
+      'content' => [
+        $this->terms[4]->getConfigDependencyName(),
+      ],
+      'module' => [
+        'node',
+        'taxonomy',
+        'user',
+      ],
+    ], $view->getDependencies());
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyIndexTidUiTest.php

@@ -0,0 +1,220 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\field\Tests\EntityReference\EntityReferenceTestTrait;
+use Drupal\taxonomy\Entity\Term;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\Tests\views_ui\Functional\UITestBase;
+use Drupal\views\Tests\ViewTestData;
+use Drupal\views\Entity\View;
+
+/**
+ * Tests the taxonomy index filter handler UI.
+ *
+ * @group taxonomy
+ * @see \Drupal\taxonomy\Plugin\views\field\TaxonomyIndexTid
+ */
+class TaxonomyIndexTidUiTest extends UITestBase {
+
+  use EntityReferenceTestTrait;
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_filter_taxonomy_index_tid', 'test_taxonomy_term_name'];
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['node', 'taxonomy', 'views', 'views_ui', 'taxonomy_test_views'];
+
+  /**
+   * A nested array of \Drupal\taxonomy\TermInterface objects.
+   *
+   * @var \Drupal\taxonomy\TermInterface[][]
+   */
+  protected $terms = [];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    $this->adminUser = $this->drupalCreateUser(['administer taxonomy', 'administer views']);
+    $this->drupalLogin($this->adminUser);
+
+    Vocabulary::create([
+      'vid' => 'tags',
+      'name' => 'Tags',
+    ])->save();
+
+    // Setup a hierarchy which looks like this:
+    // term 0.0
+    // term 1.0
+    // - term 1.1
+    // term 2.0
+    // - term 2.1
+    // - term 2.2
+    for ($i = 0; $i < 3; $i++) {
+      for ($j = 0; $j <= $i; $j++) {
+        $this->terms[$i][$j] = $term = Term::create([
+          'vid' => 'tags',
+          'name' => "Term $i.$j",
+          'parent' => isset($terms[$i][0]) ? $terms[$i][0]->id() : 0,
+        ]);
+        $term->save();
+      }
+    }
+    ViewTestData::createTestViews(get_class($this), ['taxonomy_test_views']);
+
+    Vocabulary::create([
+      'vid' => 'empty_vocabulary',
+      'name' => 'Empty Vocabulary',
+    ])->save();
+  }
+
+  /**
+   * Tests the filter UI.
+   */
+  public function testFilterUI() {
+    $this->drupalGet('admin/structure/views/nojs/handler/test_filter_taxonomy_index_tid/default/filter/tid');
+
+    $result = $this->xpath('//select[@id="edit-options-value"]/option');
+
+    // Ensure that the expected hierarchy is available in the UI.
+    $counter = 0;
+    for ($i = 0; $i < 3; $i++) {
+      for ($j = 0; $j <= $i; $j++) {
+        $option = $result[$counter++];
+        $prefix = $this->terms[$i][$j]->parent->target_id ? '-' : '';
+        $tid = $option->getAttribute('value');
+
+        $this->assertEqual($prefix . $this->terms[$i][$j]->getName(), $option->getText());
+        $this->assertEqual($this->terms[$i][$j]->id(), $tid);
+      }
+    }
+
+    // Ensure the autocomplete input element appears when using the 'textfield'
+    // type.
+    $view = View::load('test_filter_taxonomy_index_tid');
+    $display =& $view->getDisplay('default');
+    $display['display_options']['filters']['tid']['type'] = 'textfield';
+    $view->save();
+    $this->drupalGet('admin/structure/views/nojs/handler/test_filter_taxonomy_index_tid/default/filter/tid');
+    $this->assertFieldById('edit-options-value', NULL);
+
+    // Tests \Drupal\taxonomy\Plugin\views\filter\TaxonomyIndexTid::calculateDependencies().
+    $expected = [
+      'config' => [
+        'taxonomy.vocabulary.tags',
+      ],
+      'content' => [
+        'taxonomy_term:tags:' . Term::load(2)->uuid(),
+      ],
+      'module' => [
+        'node',
+        'taxonomy',
+        'user',
+      ],
+    ];
+    $this->assertIdentical($expected, $view->calculateDependencies()->getDependencies());
+  }
+
+  /**
+   * Tests exposed taxonomy filters.
+   */
+  public function testExposedFilter() {
+    $node_type = $this->drupalCreateContentType(['type' => 'page']);
+
+    // Create the tag field itself.
+    $field_name = 'taxonomy_tags';
+    $this->createEntityReferenceField('node', $node_type->id(), $field_name, NULL, 'taxonomy_term');
+
+    // Create 4 nodes: 1 without a term, 2 with the same term, and 1 with a
+    // different term.
+    $node1 = $this->drupalCreateNode();
+    $node2 = $this->drupalCreateNode([
+      $field_name => [['target_id' => $this->terms[1][0]->id()]],
+    ]);
+    $node3 = $this->drupalCreateNode([
+      $field_name => [['target_id' => $this->terms[1][0]->id()]],
+    ]);
+    $node4 = $this->drupalCreateNode([
+      $field_name => [['target_id' => $this->terms[2][0]->id()]],
+    ]);
+
+    // Only the nodes with the selected term should be shown.
+    $this->drupalGet('test-filter-taxonomy-index-tid');
+    $xpath = $this->xpath('//div[@class="view-content"]//a');
+    $this->assertIdentical(2, count($xpath));
+    $xpath = $this->xpath('//div[@class="view-content"]//a[@href=:href]', [':href' => $node2->url()]);
+    $this->assertIdentical(1, count($xpath));
+    $xpath = $this->xpath('//div[@class="view-content"]//a[@href=:href]', [':href' => $node3->url()]);
+    $this->assertIdentical(1, count($xpath));
+
+    // Expose the filter.
+    $this->drupalPostForm('admin/structure/views/nojs/handler/test_filter_taxonomy_index_tid/default/filter/tid', [], 'Expose filter');
+    // Set the operator to 'empty' and remove the default term ID.
+    $this->drupalPostForm(NULL, [
+      'options[operator]' => 'empty',
+      'options[value][]' => [],
+    ], 'Apply');
+    // Save the view.
+    $this->drupalPostForm(NULL, [], 'Save');
+
+    // After switching to 'empty' operator, the node without a term should be
+    // shown.
+    $this->drupalGet('test-filter-taxonomy-index-tid');
+    $xpath = $this->xpath('//div[@class="view-content"]//a');
+    $this->assertIdentical(1, count($xpath));
+    $xpath = $this->xpath('//div[@class="view-content"]//a[@href=:href]', [':href' => $node1->url()]);
+    $this->assertIdentical(1, count($xpath));
+
+    // Set the operator to 'not empty'.
+    $this->drupalPostForm('admin/structure/views/nojs/handler/test_filter_taxonomy_index_tid/default/filter/tid', ['options[operator]' => 'not empty'], 'Apply');
+    // Save the view.
+    $this->drupalPostForm(NULL, [], 'Save');
+
+    // After switching to 'not empty' operator, all nodes with terms should be
+    // shown.
+    $this->drupalGet('test-filter-taxonomy-index-tid');
+    $xpath = $this->xpath('//div[@class="view-content"]//a');
+    $this->assertIdentical(3, count($xpath));
+    $xpath = $this->xpath('//div[@class="view-content"]//a[@href=:href]', [':href' => $node2->url()]);
+    $this->assertIdentical(1, count($xpath));
+    $xpath = $this->xpath('//div[@class="view-content"]//a[@href=:href]', [':href' => $node3->url()]);
+    $this->assertIdentical(1, count($xpath));
+    $xpath = $this->xpath('//div[@class="view-content"]//a[@href=:href]', [':href' => $node4->url()]);
+    $this->assertIdentical(1, count($xpath));
+
+    // Select 'Term ID' as the field to be displayed.
+    $edit = ['name[taxonomy_term_field_data.tid]' => TRUE];
+    $this->drupalPostForm('admin/structure/views/nojs/add-handler/test_taxonomy_term_name/default/field', $edit, 'Add and configure fields');
+    // Select 'Term' and 'Vocabulary' as filters.
+    $edit = [
+      'name[taxonomy_term_field_data.tid]' => TRUE,
+      'name[taxonomy_term_field_data.vid]' => TRUE
+    ];
+    $this->drupalPostForm('admin/structure/views/nojs/add-handler/test_taxonomy_term_name/default/filter', $edit, 'Add and configure filter criteria');
+    // Select 'Empty Vocabulary' and 'Autocomplete' from the list of options.
+    $this->drupalPostForm('admin/structure/views/nojs/handler-extra/test_taxonomy_term_name/default/filter/tid', [], 'Apply and continue');
+    // Expose the filter.
+    $edit = ['options[expose_button][checkbox][checkbox]' => TRUE];
+    $this->drupalPostForm('admin/structure/views/nojs/handler/test_taxonomy_term_name/default/filter/tid', $edit, 'Expose filter');
+    $this->drupalPostForm('admin/structure/views/nojs/handler/test_taxonomy_term_name/default/filter/tid', $edit, 'Apply');
+    // Filter 'Taxonomy terms' belonging to 'Empty Vocabulary'.
+    $edit = ['options[value][empty_vocabulary]' => TRUE];
+    $this->drupalPostForm('admin/structure/views/nojs/handler/test_taxonomy_term_name/default/filter/vid', $edit, 'Apply');
+    $this->drupalPostForm('admin/structure/views/view/test_taxonomy_term_name/edit/default', [], 'Save');
+    $this->drupalPostForm(NULL, [], t('Update preview'));
+    $preview = $this->xpath("//div[@class='view-content']");
+    $this->assertTrue(empty($preview), 'No results.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyParentUITest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Tests\ViewTestData;
+use Drupal\Tests\views_ui\Functional\UITestBase;
+
+/**
+ * Tests views taxonomy parent plugin UI.
+ *
+ * @group taxonomy
+ * @see Drupal\taxonomy\Plugin\views\access\Role
+ */
+class TaxonomyParentUITest extends UITestBase {
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_taxonomy_parent'];
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    ViewTestData::createTestViews(get_class($this), ['taxonomy_test_views']);
+  }
+
+  /**
+   * Tests the taxonomy parent plugin UI.
+   */
+  public function testTaxonomyParentUI() {
+    $this->drupalGet('admin/structure/views/nojs/handler/test_taxonomy_parent/default/relationship/parent');
+    $this->assertNoText('The handler for this item is broken or missing.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyRelationshipTest.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\node\NodeInterface;
+use Drupal\taxonomy\TermInterface;
+use Drupal\views\Views;
+
+/**
+ * Tests taxonomy relationships with parent term and node.
+ *
+ * @group taxonomy
+ */
+class TaxonomyRelationshipTest extends TaxonomyTestBase {
+
+  /**
+   * Stores the terms used in the tests.
+   *
+   * @var \Drupal\taxonomy\TermInterface[]
+   */
+  protected $terms = [];
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_taxonomy_term_relationship'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Make term2 parent of term1.
+    $this->term1->set('parent', $this->term2->id());
+    $this->term1->save();
+    // Store terms in an array for testing.
+    $this->terms[] = $this->term1;
+    $this->terms[] = $this->term2;
+    // Only set term1 on node1 and term2 on node2 for testing.
+    unset($this->nodes[0]->field_views_testing_tags[1]);
+    $this->nodes[0]->save();
+    unset($this->nodes[1]->field_views_testing_tags[0]);
+    $this->nodes[1]->save();
+
+    Views::viewsData()->clear();
+
+  }
+
+  /**
+   * Tests the taxonomy parent plugin UI.
+   */
+  public function testTaxonomyRelationships() {
+
+    // Check the generated views data of taxonomy_index.
+    $views_data = Views::viewsData()->get('taxonomy_index');
+    // Check the table join data.
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_field_data']['left_field'], 'tid');
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_field_data']['field'], 'tid');
+    $this->assertEqual($views_data['table']['join']['node_field_data']['left_field'], 'nid');
+    $this->assertEqual($views_data['table']['join']['node_field_data']['field'], 'nid');
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_hierarchy']['left_field'], 'tid');
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_hierarchy']['field'], 'tid');
+
+    // Check the generated views data of taxonomy_term_hierarchy.
+    $views_data = Views::viewsData()->get('taxonomy_term_hierarchy');
+    // Check the table join data.
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_hierarchy']['left_field'], 'tid');
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_hierarchy']['field'], 'parent');
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_field_data']['left_field'], 'tid');
+    $this->assertEqual($views_data['table']['join']['taxonomy_term_field_data']['field'], 'tid');
+    // Check the parent relationship data.
+    $this->assertEqual($views_data['parent']['relationship']['base'], 'taxonomy_term_field_data');
+    $this->assertEqual($views_data['parent']['relationship']['field'], 'parent');
+    $this->assertEqual($views_data['parent']['relationship']['label'], t('Parent'));
+    $this->assertEqual($views_data['parent']['relationship']['id'], 'standard');
+    // Check the parent filter and argument data.
+    $this->assertEqual($views_data['parent']['filter']['id'], 'numeric');
+    $this->assertEqual($views_data['parent']['argument']['id'], 'taxonomy');
+
+    // Check an actual test view.
+    $view = Views::getView('test_taxonomy_term_relationship');
+    $this->executeView($view);
+    /** @var \Drupal\views\ResultRow $row */
+    foreach ($view->result as $index => $row) {
+      // Check that the actual ID of the entity is the expected one.
+      $this->assertEqual($row->tid, $this->terms[$index]->id());
+
+      // Also check that we have the correct result entity.
+      $this->assertEqual($row->_entity->id(), $this->terms[$index]->id());
+      $this->assertTrue($row->_entity instanceof TermInterface);
+
+      if (!$index) {
+        $this->assertTrue($row->_relationship_entities['parent'] instanceof TermInterface);
+        $this->assertEqual($row->_relationship_entities['parent']->id(), $this->term2->id());
+        $this->assertEqual($row->taxonomy_term_field_data_taxonomy_term_hierarchy_tid, $this->term2->id());
+      }
+      $this->assertTrue($row->_relationship_entities['nid'] instanceof NodeInterface);
+      $this->assertEqual($row->_relationship_entities['nid']->id(), $this->nodes[$index]->id());
+    }
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyTermArgumentDepthTest.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+/**
+ * Tests the taxonomy term with depth argument.
+ *
+ * @group taxonomy
+ */
+class TaxonomyTermArgumentDepthTest extends TaxonomyTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views', 'views', 'node'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $testViews = ['test_argument_taxonomy_index_tid_depth'];
+
+  /**
+   * @var \Drupal\taxonomy\TermInterface[]
+   */
+  protected $terms = [];
+
+  /**
+   * @var \Drupal\views\ViewExecutable
+   */
+  protected $view;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Create a term with markup in the label.
+    $first = $this->createTerm(['name' => '<em>First</em>']);
+
+    // Create a node w/o any terms.
+    $settings = ['type' => 'article'];
+
+    // Create a node with linked to the term.
+    $settings['field_views_testing_tags'][0]['target_id'] = $first->id();
+    $this->nodes[] = $this->drupalCreateNode($settings);
+
+    $this->terms[0] = $first;
+  }
+
+  /**
+   * Tests title escaping.
+   */
+  public function testTermWithDepthArgumentTitleEscaping() {
+    $this->drupalGet('test_argument_taxonomy_index_tid_depth/' . $this->terms[0]->id());
+    $this->assertEscaped($this->terms[0]->label());
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyTermFilterDepthTest.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Views;
+
+/**
+ * Test the taxonomy term with depth filter.
+ *
+ * @group taxonomy
+ */
+class TaxonomyTermFilterDepthTest extends TaxonomyTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views', 'views', 'node'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $testViews = ['test_filter_taxonomy_index_tid_depth'];
+
+  /**
+   * @var \Drupal\taxonomy\TermInterface[]
+   */
+  protected $terms = [];
+
+  /**
+   * @var \Drupal\views\ViewExecutable
+   */
+  protected $view;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Create a hierarchy 3 deep. Note the parent setup function creates two
+    // top-level terms w/o children.
+    $first = $this->createTerm(['name' => 'First']);
+    $second = $this->createTerm(['name' => 'Second', 'parent' => $first->id()]);
+    $third = $this->createTerm(['name' => 'Third', 'parent' => $second->id()]);
+
+    // Create a node w/o any terms.
+    $settings = ['type' => 'article'];
+    $this->nodes[] = $this->drupalCreateNode($settings);
+
+    // Create a node with only the top level term.
+    $settings['field_views_testing_tags'][0]['target_id'] = $first->id();
+    $this->nodes[] = $this->drupalCreateNode($settings);
+
+    // Create a node with only the third level term.
+    $settings['field_views_testing_tags'][0]['target_id'] = $third->id();
+    $this->nodes[] = $this->drupalCreateNode($settings);
+
+    $this->terms[0] = $first;
+    $this->terms[1] = $second;
+    $this->terms[2] = $third;
+
+    $this->view = Views::getView('test_filter_taxonomy_index_tid_depth');
+  }
+
+  /**
+   * Tests the terms with depth filter.
+   */
+  public function testTermWithDepthFilter() {
+    $column_map = ['nid' => 'nid'];
+    $assert_method = 'assertIdentical';
+
+    // Default view has an empty value for this filter, so all nodes should be
+    // returned.
+    $expected = [
+      ['nid' => 1],
+      ['nid' => 2],
+      ['nid' => 3],
+      ['nid' => 4],
+      ['nid' => 5],
+    ];
+    $this->executeView($this->view);
+    $this->assertIdenticalResultsetHelper($this->view, $expected, $column_map, $assert_method);
+
+    // Set filter to search on top-level term, with depth 0.
+    $expected = [['nid' => 4]];
+    $this->assertTermWithDepthResult($this->terms[0]->id(), 0, $expected);
+
+    // Top-level term, depth 1.
+    $expected = [['nid' => 4]];
+    $this->assertTermWithDepthResult($this->terms[0]->id(), 0, $expected);
+
+    // Top-level term, depth 2.
+    $expected = [['nid' => 4], ['nid' => 5]];
+    $this->assertTermWithDepthResult($this->terms[0]->id(), 2, $expected);
+
+    // Second-level term, depth 1.
+    $expected = [['nid' => 5]];
+    $this->assertTermWithDepthResult($this->terms[1]->id(), 1, $expected);
+
+    // Third-level term, depth 0.
+    $expected = [['nid' => 5]];
+    $this->assertTermWithDepthResult($this->terms[2]->id(), 0, $expected);
+
+    // Third-level term, depth 1.
+    $expected = [['nid' => 5]];
+    $this->assertTermWithDepthResult($this->terms[2]->id(), 1, $expected);
+
+    // Third-level term, depth -2.
+    $expected = [['nid' => 4], ['nid' => 5]];
+    $this->assertTermWithDepthResult($this->terms[2]->id(), -2, $expected);
+  }
+
+  /**
+   * Changes the tid filter to given term and depth.
+   *
+   * @param int $tid
+   *   The term ID to filter on.
+   * @param int $depth
+   *   The depth to search.
+   * @param array $expected
+   *   The expected views result.
+   */
+  protected function assertTermWithDepthResult($tid, $depth, array $expected) {
+    $this->view->destroy();
+    $this->view->initDisplay();
+    $filters = $this->view->displayHandlers->get('default')
+      ->getOption('filters');
+    $filters['tid_depth']['depth'] = $depth;
+    $filters['tid_depth']['value'] = [$tid];
+    $this->view->displayHandlers->get('default')
+      ->setOption('filters', $filters);
+    $this->executeView($this->view);
+    $this->assertIdenticalResultsetHelper($this->view, $expected, ['nid' => 'nid'], 'assertIdentical');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyTermViewTest.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\language\Entity\ConfigurableLanguage;
+use Drupal\user\Entity\Role;
+use Drupal\user\RoleInterface;
+use Drupal\views\Views;
+
+/**
+ * Tests the taxonomy term view page and its translation.
+ *
+ * @group taxonomy
+ */
+class TaxonomyTermViewTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'views'];
+
+  /**
+   * An user with permissions to administer taxonomy.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $adminUser;
+
+  /**
+   * Name of the taxonomy term reference field.
+   *
+   * @var string
+   */
+  protected $fieldName1;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Create an administrative user.
+    $this->adminUser = $this->drupalCreateUser(['administer taxonomy', 'bypass node access']);
+    $this->drupalLogin($this->adminUser);
+
+    // Create a vocabulary and add two term reference fields to article nodes.
+
+    $this->fieldName1 = Unicode::strtolower($this->randomMachineName());
+
+    $handler_settings = [
+      'target_bundles' => [
+        $this->vocabulary->id() => $this->vocabulary->id(),
+      ],
+      'auto_create' => TRUE,
+    ];
+    $this->createEntityReferenceField('node', 'article', $this->fieldName1, NULL, 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($this->fieldName1, [
+        'type' => 'options_select',
+      ])
+      ->save();
+    entity_get_display('node', 'article', 'default')
+      ->setComponent($this->fieldName1, [
+        'type' => 'entity_reference_label',
+      ])
+      ->save();
+  }
+
+  /**
+   * Tests that the taxonomy term view is working properly.
+   */
+  public function testTaxonomyTermView() {
+    // Create terms in the vocabulary.
+    $term = $this->createTerm();
+
+    // Post an article.
+    $edit = [];
+    $edit['title[0][value]'] = $original_title = $this->randomMachineName();
+    $edit['body[0][value]'] = $this->randomMachineName();
+    $edit["{$this->fieldName1}[]"] = $term->id();
+    $this->drupalPostForm('node/add/article', $edit, t('Save'));
+    $node = $this->drupalGetNodeByTitle($edit['title[0][value]']);
+
+    $this->drupalGet('taxonomy/term/' . $term->id());
+    $this->assertText($term->label());
+    $this->assertText($node->label());
+
+    \Drupal::service('module_installer')->install(['language', 'content_translation']);
+    $language = ConfigurableLanguage::createFromLangcode('ur');
+    $language->save();
+    // Enable translation for the article content type and ensure the change is
+    // picked up.
+    \Drupal::service('content_translation.manager')->setEnabled('node', 'article', TRUE);
+    $roles = $this->adminUser->getRoles(TRUE);
+    Role::load(reset($roles))
+      ->grantPermission('create content translations')
+      ->grantPermission('translate any entity')
+      ->save();
+    drupal_static_reset();
+    \Drupal::entityManager()->clearCachedDefinitions();
+    \Drupal::service('router.builder')->rebuild();
+    \Drupal::service('entity.definition_update_manager')->applyUpdates();
+
+    $edit['title[0][value]'] = $translated_title = $this->randomMachineName();
+
+    $this->drupalPostForm('node/' . $node->id() . '/translations/add/en/ur', $edit, t('Save (this translation)'));
+
+    $this->drupalGet('taxonomy/term/' . $term->id());
+    $this->assertText($term->label());
+    $this->assertText($original_title);
+    $this->assertNoText($translated_title);
+
+    $this->drupalGet('ur/taxonomy/term/' . $term->id());
+    $this->assertText($term->label());
+    $this->assertNoText($original_title);
+    $this->assertText($translated_title);
+
+    // Uninstall language module and ensure that the language is not part of the
+    // query anymore.
+    // @see \Drupal\views\Plugin\views\filter\LanguageFilter::query()
+    $node->delete();
+    \Drupal::service('module_installer')->uninstall(['content_translation', 'language']);
+
+    $view = Views::getView('taxonomy_term');
+    $view->initDisplay();
+    $view->setArguments([$term->id()]);
+    $view->build();
+    /** @var \Drupal\Core\Database\Query\Select $query */
+    $query = $view->build_info['query'];
+    $tables = $query->getTables();
+
+    // Ensure that the join to node_field_data is not added by default.
+    $this->assertEqual(['node_field_data', 'taxonomy_index'], array_keys($tables));
+    // Ensure that the filter to the language column is not there by default.
+    $condition = $query->conditions();
+    // We only want to check the no. of conditions in the query.
+    unset($condition['#conjunction']);
+    $this->assertEqual(1, count($condition));
+
+    // Clear permissions for anonymous users to check access for default views.
+    Role::load(RoleInterface::ANONYMOUS_ID)->revokePermission('access content')->save();
+
+    // Test the default views disclose no data by default.
+    $this->drupalLogout();
+    $this->drupalGet('taxonomy/term/' . $term->id());
+    $this->assertResponse(403);
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/feed');
+    $this->assertResponse(403);
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyTestBase.php

@@ -0,0 +1,155 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\field\Tests\EntityReference\EntityReferenceTestTrait;
+use Drupal\Tests\views\Functional\ViewTestBase;
+use Drupal\views\Tests\ViewTestData;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\taxonomy\Entity\Term;
+
+/**
+ * Base class for all taxonomy tests.
+ */
+abstract class TaxonomyTestBase extends ViewTestBase {
+
+  use EntityReferenceTestTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views'];
+
+  /**
+   * Stores the nodes used for the different tests.
+   *
+   * @var \Drupal\node\NodeInterface[]
+   */
+  protected $nodes = [];
+
+  /**
+   * The vocabulary used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * Stores the first term used in the different tests.
+   *
+   * @var \Drupal\taxonomy\TermInterface
+   */
+  protected $term1;
+
+  /**
+   * Stores the second term used in the different tests.
+   *
+   * @var \Drupal\taxonomy\TermInterface
+   */
+  protected $term2;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+    $this->mockStandardInstall();
+
+    if ($import_test_views) {
+      ViewTestData::createTestViews(get_class($this), ['taxonomy_test_views']);
+    }
+
+    $this->term1 = $this->createTerm();
+    $this->term2 = $this->createTerm();
+
+    $node = [];
+    $node['type'] = 'article';
+    $node['field_views_testing_tags'][]['target_id'] = $this->term1->id();
+    $node['field_views_testing_tags'][]['target_id'] = $this->term2->id();
+    $this->nodes[] = $this->drupalCreateNode($node);
+    $this->nodes[] = $this->drupalCreateNode($node);
+  }
+
+  /**
+   * Provides a workaround for the inability to use the standard profile.
+   *
+   * @see https://www.drupal.org/node/1708692
+   */
+  protected function mockStandardInstall() {
+    $this->drupalCreateContentType([
+      'type' => 'article',
+    ]);
+    // Create the vocabulary for the tag field.
+    $this->vocabulary = Vocabulary::create([
+      'name' => 'Views testing tags',
+      'vid' => 'views_testing_tags',
+    ]);
+    $this->vocabulary->save();
+    $field_name = 'field_' . $this->vocabulary->id();
+
+    $handler_settings = [
+      'target_bundles' => [
+        $this->vocabulary->id() => $this->vocabulary->id(),
+      ],
+      'auto_create' => TRUE,
+    ];
+    $this->createEntityReferenceField('node', 'article', $field_name, 'Tags', 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($field_name, [
+        'type' => 'entity_reference_autocomplete_tags',
+        'weight' => -4,
+      ])
+      ->save();
+
+    entity_get_display('node', 'article', 'default')
+      ->setComponent($field_name, [
+        'type' => 'entity_reference_label',
+        'weight' => 10,
+      ])
+      ->save();
+    entity_get_display('node', 'article', 'teaser')
+      ->setComponent($field_name, [
+        'type' => 'entity_reference_label',
+        'weight' => 10,
+      ])
+      ->save();
+  }
+
+  /**
+   * Creates and returns a taxonomy term.
+   *
+   * @param array $settings
+   *   (optional) An array of values to override the following default
+   *   properties of the term:
+   *   - name: A random string.
+   *   - description: A random string.
+   *   - format: First available text format.
+   *   - vid: Vocabulary ID of self::$vocabulary object.
+   *   - langcode: LANGCODE_NOT_SPECIFIED.
+   *   Defaults to an empty array.
+   *
+   * @return \Drupal\taxonomy\Entity\Term
+   *   The created taxonomy term.
+   */
+  protected function createTerm(array $settings = []) {
+    $filter_formats = filter_formats();
+    $format = array_pop($filter_formats);
+    $settings += [
+      'name' => $this->randomMachineName(),
+      'description' => $this->randomMachineName(),
+      // Use the first available text format.
+      'format' => $format->id(),
+      'vid' => $this->vocabulary->id(),
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+    ];
+    $term = Term::create($settings);
+    $term->save();
+    return $term;
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TaxonomyVocabularyArgumentTest.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Tests the vocabulary argument.
+ *
+ * @group taxonomy
+ */
+class TaxonomyVocabularyArgumentTest extends TaxonomyTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'taxonomy_test_views', 'views'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $testViews = ['test_argument_taxonomy_vocabulary'];
+
+  /**
+   * @var \Drupal\taxonomy\TermInterface[]
+   */
+  protected $terms = [];
+
+  /**
+   * Vocabularies used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface[]
+   */
+  protected $vocabularies;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE) {
+    parent::setUp($import_test_views);
+
+    // Add default vocabulary to list of vocabularies.
+    $this->vocabularies[] = $this->vocabulary;
+    // Create additional vocabulary.
+    $vocabulary = Vocabulary::create([
+      'name' => 'Views testing category',
+      'vid' => 'views_testing_category',
+    ]);
+    $vocabulary->save();
+    $this->vocabularies[] = $vocabulary;
+
+    // Create some terms.
+    $this->terms[0] = $this->createTerm([
+      'name' => 'First',
+      'vid' => $this->vocabularies[0]->id(),
+    ]);
+    $this->terms[1] = $this->createTerm([
+      'name' => 'Second',
+      'vid' => $this->vocabularies[1]->id(),
+    ]);
+  }
+
+  /**
+   * Tests the vocabulary argument handler.
+   *
+   * @see Drupal\taxonomy\Plugin\views\argument\VocabularyVid
+   */
+  public function testTermWithVocabularyArgument() {
+    $this->drupalGet('test_argument_taxonomy_vocabulary/' . $this->vocabularies[0]->id());
+    // First term should be present.
+    $this->assertText($this->terms[0]->label());
+    // Second term should not be present.
+    $this->assertNoText($this->terms[1]->label());
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/Views/TermNameFieldTest.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional\Views;
+
+use Drupal\views\Views;
+
+/**
+ * Tests the term_name field handler.
+ *
+ * @group taxonomy
+ *
+ * @see \Drupal\taxonomy\Plugin\views\field\TermName
+ */
+class TermNameFieldTest extends TaxonomyTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $testViews = ['test_taxonomy_term_name'];
+
+  /**
+   * Tests term name field plugin functionality.
+   */
+  public function testTermNameField() {
+    $this->term1->name->value = $this->randomMachineName() . ' ' . $this->randomMachineName();
+    $this->term1->save();
+
+    $user = $this->drupalCreateUser(['access content']);
+    $this->drupalLogin($user);
+
+    $view = Views::getView('test_taxonomy_term_name');
+    $view->initDisplay();
+    $this->executeView($view);
+
+    $this->assertEqual($this->term1->getName(), $view->getStyle()->getField(0, 'name'));
+    $this->assertEqual($this->term2->getName(), $view->getStyle()->getField(1, 'name'));
+
+    $view = Views::getView('test_taxonomy_term_name');
+    $display =& $view->storage->getDisplay('default');
+    $display['display_options']['fields']['name']['convert_spaces'] = TRUE;
+    $view->storage->invalidateCaches();
+    $this->executeView($view);
+
+    $this->assertEqual(str_replace(' ', '-', $this->term1->getName()), $view->getStyle()->getField(0, 'name'));
+    $this->assertEqual($this->term2->getName(), $view->getStyle()->getField(1, 'name'));
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/VocabularyCrudTest.php

@@ -0,0 +1,182 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\field\Entity\FieldStorageConfig;
+
+/**
+ * Tests loading, saving and deleting vocabularies.
+ *
+ * @group taxonomy
+ */
+class VocabularyCrudTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = ['field_test', 'taxonomy_crud'];
+
+  protected function setUp() {
+    parent::setUp();
+
+    $admin_user = $this->drupalCreateUser(['create article content', 'administer taxonomy']);
+    $this->drupalLogin($admin_user);
+    $this->vocabulary = $this->createVocabulary();
+  }
+
+  /**
+   * Test deleting a taxonomy that contains terms.
+   */
+  public function testTaxonomyVocabularyDeleteWithTerms() {
+    // Delete any existing vocabularies.
+    foreach (Vocabulary::loadMultiple() as $vocabulary) {
+      $vocabulary->delete();
+    }
+    $query = \Drupal::entityQuery('taxonomy_term')->count();
+
+    // Assert that there are no terms left.
+    $this->assertEqual(0, $query->execute(), 'There are no terms remaining.');
+
+    $terms = [];
+    for ($i = 0; $i < 5; $i++) {
+      $terms[$i] = $this->createTerm($vocabulary);
+    }
+
+    // Set up hierarchy. term 2 is a child of 1 and 4 a child of 1 and 2.
+    $terms[2]->parent = [$terms[1]->id()];
+    $terms[2]->save();
+    $terms[4]->parent = [$terms[1]->id(), $terms[2]->id()];
+    $terms[4]->save();
+
+    // Assert that there are now 5 terms.
+    $this->assertEqual(5, $query->execute(), 'There are 5 terms found.');
+
+    $vocabulary->delete();
+
+    // Assert that there are no terms left.
+    $this->assertEqual(0, $query->execute(), 'All terms are deleted.');
+  }
+
+  /**
+   * Ensure that the vocabulary static reset works correctly.
+   */
+  public function testTaxonomyVocabularyLoadStaticReset() {
+    $original_vocabulary = Vocabulary::load($this->vocabulary->id());
+    $this->assertTrue(is_object($original_vocabulary), 'Vocabulary loaded successfully.');
+    $this->assertEqual($this->vocabulary->label(), $original_vocabulary->label(), 'Vocabulary loaded successfully.');
+
+    // Change the name and description.
+    $vocabulary = $original_vocabulary;
+    $vocabulary->set('name', $this->randomMachineName());
+    $vocabulary->set('description', $this->randomMachineName());
+    $vocabulary->save();
+
+    // Load the vocabulary.
+    $new_vocabulary = Vocabulary::load($original_vocabulary->id());
+    $this->assertEqual($new_vocabulary->label(), $vocabulary->label(), 'The vocabulary was loaded.');
+
+    // Delete the vocabulary.
+    $this->vocabulary->delete();
+    $vocabularies = Vocabulary::loadMultiple();
+    $this->assertTrue(!isset($vocabularies[$this->vocabulary->id()]), 'The vocabulary was deleted.');
+  }
+
+  /**
+   * Tests for loading multiple vocabularies.
+   */
+  public function testTaxonomyVocabularyLoadMultiple() {
+
+    // Delete any existing vocabularies.
+    foreach (Vocabulary::loadMultiple() as $vocabulary) {
+      $vocabulary->delete();
+    }
+
+    // Create some vocabularies and assign weights.
+    $vocabulary1 = $this->createVocabulary();
+    $vocabulary1->set('weight', 0);
+    $vocabulary1->save();
+    $vocabulary2 = $this->createVocabulary();
+    $vocabulary2->set('weight', 1);
+    $vocabulary2->save();
+    $vocabulary3 = $this->createVocabulary();
+    $vocabulary3->set('weight', 2);
+    $vocabulary3->save();
+
+    // Check if third party settings exist.
+    $this->assertEqual('bar', $vocabulary1->getThirdPartySetting('taxonomy_crud', 'foo'), 'Third party settings were added to the vocabulary.');
+    $this->assertEqual('bar', $vocabulary2->getThirdPartySetting('taxonomy_crud', 'foo'), 'Third party settings were added to the vocabulary.');
+    $this->assertEqual('bar', $vocabulary3->getThirdPartySetting('taxonomy_crud', 'foo'), 'Third party settings were added to the vocabulary.');
+
+    // Fetch the names for all vocabularies, confirm that they are keyed by
+    // machine name.
+    $names = taxonomy_vocabulary_get_names();
+    $this->assertEqual($names[$vocabulary1->id()], $vocabulary1->id(), 'Vocabulary 1 name found.');
+
+    // Fetch the vocabularies with entity_load_multiple(), specifying IDs.
+    // Ensure they are returned in the same order as the original array.
+    $vocabularies = Vocabulary::loadMultiple([$vocabulary3->id(), $vocabulary2->id(), $vocabulary1->id()]);
+    $loaded_order = array_keys($vocabularies);
+    $expected_order = [$vocabulary3->id(), $vocabulary2->id(), $vocabulary1->id()];
+    $this->assertIdentical($loaded_order, $expected_order);
+
+    // Test loading vocabularies by their properties.
+    $controller = $this->container->get('entity.manager')->getStorage('taxonomy_vocabulary');
+    // Fetch vocabulary 1 by name.
+    $vocabulary = current($controller->loadByProperties(['name' => $vocabulary1->label()]));
+    $this->assertEqual($vocabulary->id(), $vocabulary1->id(), 'Vocabulary loaded successfully by name.');
+
+    // Fetch vocabulary 2 by name and ID.
+    $vocabulary = current($controller->loadByProperties([
+      'name' => $vocabulary2->label(),
+      'vid' => $vocabulary2->id(),
+    ]));
+    $this->assertEqual($vocabulary->id(), $vocabulary2->id(), 'Vocabulary loaded successfully by name and ID.');
+  }
+
+  /**
+   * Test uninstall and reinstall of the taxonomy module.
+   */
+  public function testUninstallReinstall() {
+    // Field storages and fields attached to taxonomy term bundles should be
+    // removed when the module is uninstalled.
+    $field_name = Unicode::strtolower($this->randomMachineName() . '_field_name');
+    $storage_definition = [
+      'field_name' => $field_name,
+      'entity_type' => 'taxonomy_term',
+      'type' => 'text',
+      'cardinality' => 4
+    ];
+    FieldStorageConfig::create($storage_definition)->save();
+    $field_definition = [
+      'field_name' => $field_name,
+      'entity_type' => 'taxonomy_term',
+      'bundle' => $this->vocabulary->id(),
+      'label' => $this->randomMachineName() . '_label',
+    ];
+    FieldConfig::create($field_definition)->save();
+
+    // Remove the third party setting from the memory copy of the vocabulary.
+    // We keep this invalid copy around while the taxonomy module is not even
+    // installed for testing below.
+    $this->vocabulary->unsetThirdPartySetting('taxonomy_crud', 'foo');
+
+    require_once \Drupal::root() . '/core/includes/install.inc';
+    $this->container->get('module_installer')->uninstall(['taxonomy']);
+    $this->container->get('module_installer')->install(['taxonomy']);
+
+    // Now create a vocabulary with the same name. All fields
+    // connected to this vocabulary name should have been removed when the
+    // module was uninstalled. Creating a new field with the same name and
+    // an instance of this field on the same bundle name should be successful.
+    $this->vocabulary->enforceIsNew();
+    $this->vocabulary->save();
+    FieldStorageConfig::create($storage_definition)->save();
+    FieldConfig::create($field_definition)->save();
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/VocabularyLanguageTest.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\language\Entity\ConfigurableLanguage;
+use Drupal\language\Entity\ContentLanguageSettings;
+
+/**
+ * Tests the language functionality for vocabularies.
+ *
+ * @group taxonomy
+ */
+class VocabularyLanguageTest extends TaxonomyTestBase {
+
+  public static $modules = ['language'];
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Create an administrative user.
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy']));
+
+    // Add some custom languages.
+    ConfigurableLanguage::create([
+      'id' => 'aa',
+      'label' => $this->randomMachineName(),
+    ])->save();
+
+    ConfigurableLanguage::create([
+      'id' => 'bb',
+      'label' => $this->randomMachineName(),
+    ])->save();
+  }
+
+  /**
+   * Tests language settings for vocabularies.
+   */
+  public function testVocabularyLanguage() {
+    $this->drupalGet('admin/structure/taxonomy/add');
+
+    // Check that we have the language selector available.
+    $this->assertField('edit-langcode', 'The language selector field was found on the page.');
+
+    // Create the vocabulary.
+    $vid = Unicode::strtolower($this->randomMachineName());
+    $edit['name'] = $this->randomMachineName();
+    $edit['description'] = $this->randomMachineName();
+    $edit['langcode'] = 'aa';
+    $edit['vid'] = $vid;
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+
+    // Check the language on the edit page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vid);
+    $this->assertOptionSelected('edit-langcode', $edit['langcode'], 'The vocabulary language was correctly selected.');
+
+    // Change the language and save again.
+    $edit['langcode'] = 'bb';
+    unset($edit['vid']);
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+
+    // Check again the language on the edit page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vid);
+    $this->assertOptionSelected('edit-langcode', $edit['langcode'], 'The vocabulary language was correctly selected.');
+  }
+
+  /**
+   * Tests term language settings for vocabulary terms are saved and updated.
+   */
+  public function testVocabularyDefaultLanguageForTerms() {
+    // Add a new vocabulary and check that the default language settings are for
+    // the terms are saved.
+    $edit = [
+      'name' => $this->randomMachineName(),
+      'vid' => Unicode::strtolower($this->randomMachineName()),
+      'default_language[langcode]' => 'bb',
+      'default_language[language_alterable]' => TRUE,
+    ];
+    $vid = $edit['vid'];
+    $this->drupalPostForm('admin/structure/taxonomy/add', $edit, t('Save'));
+
+    // Check that the vocabulary was actually created.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $edit['vid']);
+    $this->assertResponse(200, 'The vocabulary has been created.');
+
+    // Check that the language settings were saved.
+    $language_settings = ContentLanguageSettings::loadByEntityTypeBundle('taxonomy_term', $edit['vid']);
+    $this->assertEqual($language_settings->getDefaultLangcode(), 'bb', 'The langcode was saved.');
+    $this->assertTrue($language_settings->isLanguageAlterable(), 'The visibility setting was saved.');
+
+    // Check that the correct options are selected in the interface.
+    $this->assertOptionSelected('edit-default-language-langcode', 'bb', 'The correct default language for the terms of this vocabulary is selected.');
+    $this->assertFieldChecked('edit-default-language-language-alterable', 'Show language selection option is checked.');
+
+    // Edit the vocabulary and check that the new settings are updated.
+    $edit = [
+      'default_language[langcode]' => 'aa',
+      'default_language[language_alterable]' => FALSE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $vid, $edit, t('Save'));
+
+    // And check again the settings and also the interface.
+    $language_settings = ContentLanguageSettings::loadByEntityTypeBundle('taxonomy_term', $vid);
+    $this->assertEqual($language_settings->getDefaultLangcode(), 'aa', 'The langcode was saved.');
+    $this->assertFalse($language_settings->isLanguageAlterable(), 'The visibility setting was saved.');
+
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vid);
+    $this->assertOptionSelected('edit-default-language-langcode', 'aa', 'The correct default language for the terms of this vocabulary is selected.');
+    $this->assertNoFieldChecked('edit-default-language-language-alterable', 'Show language selection option is not checked.');
+
+    // Check that language settings are changed after editing vocabulary.
+    $edit = [
+      'name' => $this->randomMachineName(),
+      'default_language[langcode]' => 'authors_default',
+      'default_language[language_alterable]' => FALSE,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/manage/' . $vid, $edit, t('Save'));
+
+    // Check that we have the new settings.
+    $new_settings = ContentLanguageSettings::loadByEntityTypeBundle('taxonomy_term', $vid);
+    $this->assertEqual($new_settings->getDefaultLangcode(), 'authors_default', 'The langcode was saved.');
+    $this->assertFalse($new_settings->isLanguageAlterable(), 'The new visibility setting was saved.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/VocabularyPermissionsTest.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+/**
+ * Tests the taxonomy vocabulary permissions.
+ *
+ * @group taxonomy
+ */
+class VocabularyPermissionsTest extends TaxonomyTestBase {
+
+  protected function setUp() {
+    parent::setUp();
+
+    $this->drupalPlaceBlock('page_title_block');
+  }
+
+  /**
+   * Create, edit and delete a taxonomy term via the user interface.
+   */
+  public function testVocabularyPermissionsTaxonomyTerm() {
+    // Vocabulary used for creating, removing and editing terms.
+    $vocabulary = $this->createVocabulary();
+
+    // Test as admin user.
+    $user = $this->drupalCreateUser(['administer taxonomy']);
+    $this->drupalLogin($user);
+
+    // Visit the main taxonomy administration page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vocabulary->id() . '/add');
+    $this->assertResponse(200);
+    $this->assertField('edit-name-0-value', 'Add taxonomy term form opened successfully.');
+
+    // Submit the term.
+    $edit = [];
+    $edit['name[0][value]'] = $this->randomMachineName();
+
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $this->assertText(t('Created new term @name.', ['@name' => $edit['name[0][value]']]), 'Term created successfully.');
+
+    // Verify that the creation message contains a link to a term.
+    $view_link = $this->xpath('//div[@class="messages"]//a[contains(@href, :href)]', [':href' => 'term/']);
+    $this->assert(isset($view_link), 'The message area contains a link to a term');
+
+    $terms = taxonomy_term_load_multiple_by_name($edit['name[0][value]']);
+    $term = reset($terms);
+
+    // Edit the term.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertResponse(200);
+    $this->assertText($edit['name[0][value]'], 'Edit taxonomy term form opened successfully.');
+
+    $edit['name[0][value]'] = $this->randomMachineName();
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $this->assertText(t('Updated term @name.', ['@name' => $edit['name[0][value]']]), 'Term updated successfully.');
+
+    // Delete the vocabulary.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/delete');
+    $this->assertRaw(t('Are you sure you want to delete the @entity-type %label?', ['@entity-type' => 'taxonomy term', '%label' => $edit['name[0][value]']]), 'Delete taxonomy term form opened successfully.');
+
+    // Confirm deletion.
+    $this->drupalPostForm(NULL, NULL, t('Delete'));
+    $this->assertRaw(t('Deleted term %name.', ['%name' => $edit['name[0][value]']]), 'Term deleted.');
+
+    // Test as user with "edit" permissions.
+    $user = $this->drupalCreateUser(["edit terms in {$vocabulary->id()}"]);
+    $this->drupalLogin($user);
+
+    // Visit the main taxonomy administration page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vocabulary->id() . '/add');
+    $this->assertResponse(403, 'Add taxonomy term form open failed.');
+
+    // Create a test term.
+    $term = $this->createTerm($vocabulary);
+
+    // Edit the term.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertResponse(200);
+    $this->assertText($term->getName(), 'Edit taxonomy term form opened successfully.');
+
+    $edit['name[0][value]'] = $this->randomMachineName();
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $this->assertText(t('Updated term @name.', ['@name' => $edit['name[0][value]']]), 'Term updated successfully.');
+
+    // Verify that the update message contains a link to a term.
+    $view_link = $this->xpath('//div[@class="messages"]//a[contains(@href, :href)]', [':href' => 'term/']);
+    $this->assert(isset($view_link), 'The message area contains a link to a term');
+
+    // Delete the vocabulary.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/delete');
+    $this->assertResponse(403, 'Delete taxonomy term form open failed.');
+
+    // Test as user with "delete" permissions.
+    $user = $this->drupalCreateUser(["delete terms in {$vocabulary->id()}"]);
+    $this->drupalLogin($user);
+
+    // Visit the main taxonomy administration page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vocabulary->id() . '/add');
+    $this->assertResponse(403, 'Add taxonomy term form open failed.');
+
+    // Create a test term.
+    $term = $this->createTerm($vocabulary);
+
+    // Edit the term.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertResponse(403, 'Edit taxonomy term form open failed.');
+
+    // Delete the vocabulary.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/delete');
+    $this->assertRaw(t('Are you sure you want to delete the @entity-type %label?', ['@entity-type' => 'taxonomy term', '%label' => $term->getName()]), 'Delete taxonomy term form opened successfully.');
+
+    // Confirm deletion.
+    $this->drupalPostForm(NULL, NULL, t('Delete'));
+    $this->assertRaw(t('Deleted term %name.', ['%name' => $term->getName()]), 'Term deleted.');
+
+    // Test as user without proper permissions.
+    $user = $this->drupalCreateUser();
+    $this->drupalLogin($user);
+
+    // Visit the main taxonomy administration page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vocabulary->id() . '/add');
+    $this->assertResponse(403, 'Add taxonomy term form open failed.');
+
+    // Create a test term.
+    $term = $this->createTerm($vocabulary);
+
+    // Edit the term.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/edit');
+    $this->assertResponse(403, 'Edit taxonomy term form open failed.');
+
+    // Delete the vocabulary.
+    $this->drupalGet('taxonomy/term/' . $term->id() . '/delete');
+    $this->assertResponse(403, 'Delete taxonomy term form open failed.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/VocabularySerializationTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Regression test for https://www.drupal.org/node/2807263.
+ *
+ * When a Vocabulary entity is unserialized before the modules have been loaded
+ * (which happens in the KernelPreHandle Stack middleware), then the constants
+ * that the Vocabulary entity uses are not yet available because they are set in
+ * taxonomy.module. This means that for example the PageCache middleware cannot
+ * load any cached Vocabulary entity, because unserialization will fail.
+ *
+ * @group taxonomy
+ */
+class VocabularySerializationTest extends BrowserTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'vocabulary_serialization_test'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    parent::setUp();
+
+    Vocabulary::create(['vid' => 'test'])->save();
+  }
+
+  public function testSerialization() {
+    $this->drupalGet('/vocabulary_serialization_test/test');
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSame('this is the output', $this->getSession()->getPage()->getContent());
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+
+    $this->drupalGet('/vocabulary_serialization_test/test');
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSame('this is the output', $this->getSession()->getPage()->getContent());
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/VocabularyTranslationTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\Component\Utility\Unicode;
+
+/**
+ * Tests content translation for vocabularies.
+ *
+ * @group taxonomy
+ */
+class VocabularyTranslationTest extends TaxonomyTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['content_translation', 'language'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Create an administrative user.
+    $this->drupalLogin($this->drupalCreateUser([
+      'administer taxonomy',
+      'administer content translation',
+    ]));
+  }
+
+  /**
+   * Tests language settings for vocabularies.
+   */
+  public function testVocabularyLanguage() {
+    $this->drupalGet('admin/structure/taxonomy/add');
+
+    // Check that the field to enable content translation is available.
+    $this->assertField('edit-default-language-content-translation', 'The content translation checkbox is present on the page.');
+
+    // Create the vocabulary.
+    $vid = Unicode::strtolower($this->randomMachineName());
+    $edit['name'] = $this->randomMachineName();
+    $edit['description'] = $this->randomMachineName();
+    $edit['langcode'] = 'en';
+    $edit['vid'] = $vid;
+    $edit['default_language[content_translation]'] = TRUE;
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+
+    // Check if content translation is enabled on the edit page.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vid);
+    $this->assertFieldChecked('edit-default-language-content-translation', 'The content translation was correctly selected.');
+  }
+
+}

core/modules/taxonomy/tests/src/Functional/VocabularyUiTest.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+use Drupal\Component\Utility\Unicode;
+
+use Drupal\Core\Url;
+use Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Tests the taxonomy vocabulary interface.
+ *
+ * @group taxonomy
+ */
+class VocabularyUiTest extends TaxonomyTestBase {
+
+  /**
+   * The vocabulary used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy']));
+    $this->vocabulary = $this->createVocabulary();
+    $this->drupalPlaceBlock('local_actions_block');
+    $this->drupalPlaceBlock('page_title_block');
+  }
+
+  /**
+   * Create, edit and delete a vocabulary via the user interface.
+   */
+  public function testVocabularyInterface() {
+    // Visit the main taxonomy administration page.
+    $this->drupalGet('admin/structure/taxonomy');
+
+    // Create a new vocabulary.
+    $this->clickLink(t('Add vocabulary'));
+    $edit = [];
+    $vid = Unicode::strtolower($this->randomMachineName());
+    $edit['name'] = $this->randomMachineName();
+    $edit['description'] = $this->randomMachineName();
+    $edit['vid'] = $vid;
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $this->assertRaw(t('Created new vocabulary %name.', ['%name' => $edit['name']]), 'Vocabulary created successfully.');
+
+    // Edit the vocabulary.
+    $this->drupalGet('admin/structure/taxonomy');
+    $this->assertText($edit['name'], 'Vocabulary name found in the vocabulary overview listing.');
+    $this->assertText($edit['description'], 'Vocabulary description found in the vocabulary overview listing.');
+    $this->assertLinkByHref(Url::fromRoute('entity.taxonomy_term.add_form', ['taxonomy_vocabulary' => $edit['vid']])->toString());
+    $this->clickLink(t('Edit vocabulary'));
+    $edit = [];
+    $edit['name'] = $this->randomMachineName();
+    $edit['description'] = $this->randomMachineName();
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+    $this->drupalGet('admin/structure/taxonomy');
+    $this->assertText($edit['name'], 'Vocabulary name found in the vocabulary overview listing.');
+    $this->assertText($edit['description'], 'Vocabulary description found in the vocabulary overview listing.');
+
+    // Try to submit a vocabulary with a duplicate machine name.
+    $edit['vid'] = $vid;
+    $this->drupalPostForm('admin/structure/taxonomy/add', $edit, t('Save'));
+    $this->assertText(t('The machine-readable name is already in use. It must be unique.'));
+
+    // Try to submit an invalid machine name.
+    $edit['vid'] = '!&^%';
+    $this->drupalPostForm('admin/structure/taxonomy/add', $edit, t('Save'));
+    $this->assertText(t('The machine-readable name must contain only lowercase letters, numbers, and underscores.'));
+
+    // Ensure that vocabulary titles are escaped properly.
+    $edit = [];
+    $edit['name'] = 'Don\'t Panic';
+    $edit['description'] = $this->randomMachineName();
+    $edit['vid'] = 'don_t_panic';
+    $this->drupalPostForm('admin/structure/taxonomy/add', $edit, t('Save'));
+
+    $site_name = $this->config('system.site')->get('name');
+    $this->assertTitle(t('Don\'t Panic | @site-name', ['@site-name' => $site_name]), 'The page title contains the escaped character.');
+  }
+
+  /**
+   * Changing weights on the vocabulary overview with two or more vocabularies.
+   */
+  public function testTaxonomyAdminChangingWeights() {
+    // Create some vocabularies.
+    for ($i = 0; $i < 10; $i++) {
+      $this->createVocabulary();
+    }
+    // Get all vocabularies and change their weights.
+    $vocabularies = Vocabulary::loadMultiple();
+    $edit = [];
+    foreach ($vocabularies as $key => $vocabulary) {
+      $weight = -$vocabulary->get('weight');
+      $vocabularies[$key]->set('weight', $weight);
+      $edit['vocabularies[' . $key . '][weight]'] = $weight;
+    }
+    // Saving the new weights via the interface.
+    $this->drupalPostForm('admin/structure/taxonomy', $edit, t('Save'));
+
+    // Load the vocabularies from the database.
+    $this->container->get('entity.manager')->getStorage('taxonomy_vocabulary')->resetCache();
+    $new_vocabularies = Vocabulary::loadMultiple();
+
+    // Check that the weights are saved in the database correctly.
+    foreach ($vocabularies as $key => $vocabulary) {
+      $this->assertEqual($new_vocabularies[$key]->get('weight'), $vocabularies[$key]->get('weight'), 'The vocabulary weight was changed.');
+    }
+  }
+
+  /**
+   * Test the vocabulary overview with no vocabularies.
+   */
+  public function testTaxonomyAdminNoVocabularies() {
+    // Delete all vocabularies.
+    $vocabularies = Vocabulary::loadMultiple();
+    foreach ($vocabularies as $key => $vocabulary) {
+      $vocabulary->delete();
+    }
+    // Confirm that no vocabularies are found in the database.
+    $this->assertFalse(Vocabulary::loadMultiple(), 'No vocabularies found.');
+    $this->drupalGet('admin/structure/taxonomy');
+    // Check the default message for no vocabularies.
+    $this->assertText(t('No vocabularies available.'));
+  }
+
+  /**
+   * Deleting a vocabulary.
+   */
+  public function testTaxonomyAdminDeletingVocabulary() {
+    // Create a vocabulary.
+    $vid = Unicode::strtolower($this->randomMachineName());
+    $edit = [
+      'name' => $this->randomMachineName(),
+      'vid' => $vid,
+    ];
+    $this->drupalPostForm('admin/structure/taxonomy/add', $edit, t('Save'));
+    $this->assertText(t('Created new vocabulary'), 'New vocabulary was created.');
+
+    // Check the created vocabulary.
+    $this->container->get('entity.manager')->getStorage('taxonomy_vocabulary')->resetCache();
+    $vocabulary = Vocabulary::load($vid);
+    $this->assertTrue($vocabulary, 'Vocabulary found.');
+
+    // Delete the vocabulary.
+    $this->drupalGet('admin/structure/taxonomy/manage/' . $vocabulary->id());
+    $this->clickLink(t('Delete'));
+    $this->assertRaw(t('Are you sure you want to delete the vocabulary %name?', ['%name' => $vocabulary->label()]), '[confirm deletion] Asks for confirmation.');
+    $this->assertText(t('Deleting a vocabulary will delete all the terms in it. This action cannot be undone.'), '[confirm deletion] Inform that all terms will be deleted.');
+
+    // Confirm deletion.
+    $this->drupalPostForm(NULL, NULL, t('Delete'));
+    $this->assertRaw(t('Deleted vocabulary %name.', ['%name' => $vocabulary->label()]), 'Vocabulary deleted.');
+    $this->container->get('entity.manager')->getStorage('taxonomy_vocabulary')->resetCache();
+    $this->assertFalse(Vocabulary::load($vid), 'Vocabulary not found.');
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/ForwardRevisionTest.php

@@ -113,9 +113,9 @@ class ForwardRevisionTest extends KernelTestBase {
 
   protected function getTaxonomyIndex() {
     return \Drupal::database()->select('taxonomy_index')
-     ->fields('taxonomy_index')
-     ->execute()
-     ->fetchAllAssoc('nid');
+      ->fields('taxonomy_index')
+      ->execute()
+      ->fetchAllAssoc('nid');
   }
 
 }

core/modules/taxonomy/tests/src/Kernel/Migrate/MigrateTaxonomyConfigsTest.php

@@ -2,7 +2,7 @@
 
 namespace Drupal\Tests\taxonomy\Kernel\Migrate;
 
-use Drupal\config\Tests\SchemaCheckTestTrait;
+use Drupal\Tests\SchemaCheckTestTrait;
 use Drupal\Tests\migrate_drupal\Kernel\d6\MigrateDrupal6TestBase;
 
 /**
@@ -17,7 +17,7 @@ class MigrateTaxonomyConfigsTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = array('taxonomy');
+  public static $modules = ['taxonomy'];
 
   /**
    * {@inheritdoc}

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateTaxonomyTermTest.php

@@ -15,7 +15,7 @@ class MigrateTaxonomyTermTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = array('taxonomy');
+  public static $modules = ['taxonomy'];
 
   /**
    * {@inheritdoc}
@@ -30,44 +30,47 @@ class MigrateTaxonomyTermTest extends MigrateDrupal6TestBase {
    * Tests the Drupal 6 taxonomy term to Drupal 8 migration.
    */
   public function testTaxonomyTerms() {
-    $expected_results = array(
-      '1' => array(
+    $expected_results = [
+      '1' => [
         'source_vid' => 1,
         'vid' => 'vocabulary_1_i_0_',
         'weight' => 0,
-        'parent' => array(0),
-      ),
-      '2' => array(
+        'parent' => [0],
+        'language' => 'zu',
+      ],
+      '2' => [
         'source_vid' => 2,
         'vid' => 'vocabulary_2_i_1_',
         'weight' => 3,
-        'parent' => array(0),
-      ),
-      '3' => array(
+        'parent' => [0],
+        'language' => 'fr',
+      ],
+      '3' => [
         'source_vid' => 2,
         'vid' => 'vocabulary_2_i_1_',
         'weight' => 4,
-        'parent' => array(2),
-      ),
-      '4' => array(
+        'parent' => [2],
+        'language' => 'fr',
+      ],
+      '4' => [
         'source_vid' => 3,
         'vid' => 'vocabulary_3_i_2_',
         'weight' => 6,
-        'parent' => array(0),
-      ),
-      '5' => array(
+        'parent' => [0],
+      ],
+      '5' => [
         'source_vid' => 3,
         'vid' => 'vocabulary_3_i_2_',
         'weight' => 7,
-        'parent' => array(4),
-      ),
-      '6' => array(
+        'parent' => [4],
+      ],
+      '6' => [
         'source_vid' => 3,
         'vid' => 'vocabulary_3_i_2_',
         'weight' => 8,
-        'parent' => array(4, 5),
-      ),
-    );
+        'parent' => [4, 5],
+      ],
+    ];
     $terms = Term::loadMultiple(array_keys($expected_results));
 
     // Find each term in the tree.
@@ -83,15 +86,16 @@ class MigrateTaxonomyTermTest extends MigrateDrupal6TestBase {
     foreach ($expected_results as $tid => $values) {
       /** @var Term $term */
       $term = $terms[$tid];
-      $this->assertIdentical("term {$tid} of vocabulary {$values['source_vid']}", $term->name->value);
-      $this->assertIdentical("description of term {$tid} of vocabulary {$values['source_vid']}", $term->description->value);
+      $language = isset($values['language']) ? $values['language'] . ' - ' : '';
+      $this->assertSame("{$language}term {$tid} of vocabulary {$values['source_vid']}", $term->name->value);
+      $this->assertSame("{$language}description of term {$tid} of vocabulary {$values['source_vid']}", $term->description->value);
       $this->assertIdentical($values['vid'], $term->vid->target_id);
       $this->assertIdentical((string) $values['weight'], $term->weight->value);
-      if ($values['parent'] === array(0)) {
+      if ($values['parent'] === [0]) {
         $this->assertNull($term->parent->target_id);
       }
       else {
-        $parents = array();
+        $parents = [];
         foreach (\Drupal::entityManager()->getStorage('taxonomy_term')->loadParents($tid) as $parent) {
           $parents[] = (int) $parent->id();
         }

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateTaxonomyTermTranslationTest.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Migrate\d6;
+
+use Drupal\taxonomy\Entity\Term;
+use Drupal\Tests\migrate_drupal\Kernel\d6\MigrateDrupal6TestBase;
+use Drupal\taxonomy\TermInterface;
+
+/**
+ * Test migration of translated taxonomy terms.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateTaxonomyTermTranslationTest extends MigrateDrupal6TestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'language',
+    'menu_ui',
+    'node',
+    'taxonomy',
+  ];
+
+  /**
+   * The cached taxonomy tree items, keyed by vid and tid.
+   *
+   * @var array
+   */
+  protected $treeData = [];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installEntitySchema('taxonomy_term');
+    $this->installConfig(static::$modules);
+    $this->executeMigrations([
+      'd6_node_type',
+      'd6_field',
+      'd6_taxonomy_vocabulary',
+      'd6_field_instance',
+      'd6_taxonomy_term',
+      'd6_taxonomy_term_translation',
+    ]);
+  }
+
+  /**
+   * Validate a migrated term contains the expected values.
+   *
+   * @param int $id
+   *   Entity ID to load and check.
+   * @param string $expected_language
+   *   The language code for this term.
+   * @param string $expected_label
+   *   The label the migrated entity should have.
+   * @param string $expected_vid
+   *   The parent vocabulary the migrated entity should have.
+   * @param string $expected_description
+   *   The description the migrated entity should have.
+   * @param string $expected_format
+   *   The format the migrated entity should have.
+   * @param int $expected_weight
+   *   The weight the migrated entity should have.
+   * @param array $expected_parents
+   *   The parent terms the migrated entity should have.
+   * @param int $expected_field_integer_value
+   *   The value the migrated entity field should have.
+   * @param int $expected_term_reference_tid
+   *   The term reference ID the migrated entity field should have.
+   */
+  protected function assertEntity($id, $expected_language, $expected_label, $expected_vid, $expected_description = '', $expected_format = NULL, $expected_weight = 0, $expected_parents = [], $expected_field_integer_value = NULL, $expected_term_reference_tid = NULL) {
+    /** @var \Drupal\taxonomy\TermInterface $entity */
+    $entity = Term::load($id);
+    $this->assertInstanceOf(TermInterface::class, $entity);
+    $this->assertSame($expected_language, $entity->language()->getId());
+    $this->assertSame($expected_label, $entity->label());
+    $this->assertSame($expected_vid, $entity->getVocabularyId());
+    $this->assertSame($expected_description, $entity->getDescription());
+    $this->assertSame($expected_format, $entity->getFormat());
+    $this->assertSame($expected_weight, $entity->getWeight());
+    $this->assertHierarchy($expected_vid, $id, $expected_parents);
+  }
+
+  /**
+   * Assert that a term is present in the tree storage, with the right parents.
+   *
+   * @param string $vid
+   *   Vocabulary ID.
+   * @param int $tid
+   *   ID of the term to check.
+   * @param array $parent_ids
+   *   The expected parent term IDs.
+   */
+  protected function assertHierarchy($vid, $tid, array $parent_ids) {
+    if (!isset($this->treeData[$vid])) {
+      $tree = \Drupal::entityTypeManager()->getStorage('taxonomy_term')->loadTree($vid);
+      $this->treeData[$vid] = [];
+      foreach ($tree as $item) {
+        $this->treeData[$vid][$item->tid] = $item;
+      }
+    }
+
+    $this->assertArrayHasKey($tid, $this->treeData[$vid], "Term $tid exists in taxonomy tree");
+    $term = $this->treeData[$vid][$tid];
+    $this->assertEquals($parent_ids, array_filter($term->parents), "Term $tid has correct parents in taxonomy tree");
+  }
+
+  /**
+   * Tests the Drupal 6 i18n taxonomy term to Drupal 8 migration.
+   */
+  public function testTranslatedTaxonomyTerms() {
+    $this->assertEntity(1, 'zu', 'zu - term 1 of vocabulary 1', 'vocabulary_1_i_0_', 'zu - description of term 1 of vocabulary 1', NULL, '0', []);
+    $this->assertEntity(2, 'fr', 'fr - term 2 of vocabulary 2', 'vocabulary_2_i_1_', 'fr - description of term 2 of vocabulary 2', NULL, '3', []);
+    $this->assertEntity(3, 'fr', 'fr - term 3 of vocabulary 2', 'vocabulary_2_i_1_', 'fr - description of term 3 of vocabulary 2', NULL, '4', ['2']);
+    $this->assertEntity(4, 'en', 'term 4 of vocabulary 3', 'vocabulary_3_i_2_', 'description of term 4 of vocabulary 3', NULL, '6', []);
+    $this->assertEntity(5, 'en', 'term 5 of vocabulary 3', 'vocabulary_3_i_2_', 'description of term 5 of vocabulary 3', NULL, '7', ['4']);
+    $this->assertEntity(6, 'en', 'term 6 of vocabulary 3', 'vocabulary_3_i_2_', 'description of term 6 of vocabulary 3', NULL, '8', ['4', '5']);
+    $this->assertEntity(7, 'fr', 'fr - term 2 of vocabulary 1', 'vocabulary_1_i_0_', 'fr - desc of term 2 vocab 1', NULL, '0', []);
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateTaxonomyVocabularyTest.php

@@ -15,7 +15,7 @@ class MigrateTaxonomyVocabularyTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = array('taxonomy');
+  public static $modules = ['taxonomy'];
 
   /**
    * {@inheritdoc}
@@ -32,7 +32,7 @@ class MigrateTaxonomyVocabularyTest extends MigrateDrupal6TestBase {
     for ($i = 0; $i < 3; $i++) {
       $j = $i + 1;
       $vocabulary = Vocabulary::load("vocabulary_{$j}_i_{$i}_");
-      $this->assertIdentical($this->getMigration('d6_taxonomy_vocabulary')->getIdMap()->lookupDestinationID(array($j)), array($vocabulary->id()));
+      $this->assertIdentical($this->getMigration('d6_taxonomy_vocabulary')->getIdMap()->lookupDestinationID([$j]), [$vocabulary->id()]);
       $this->assertIdentical("vocabulary $j (i=$i)", $vocabulary->label());
       $this->assertIdentical("description of vocabulary $j (i=$i)", $vocabulary->getDescription());
       $this->assertIdentical($i, $vocabulary->getHierarchy());

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateTaxonomyVocabularyTranslationTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Migrate\d6;
+
+use Drupal\Tests\migrate_drupal\Kernel\d6\MigrateDrupal6TestBase;
+
+/**
+ * Migrate taxonomy vocabularies to taxonomy.vocabulary.*.yml.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateTaxonomyVocabularyTranslationTest extends MigrateDrupal6TestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['language', 'taxonomy'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->executeMigrations([
+      'd6_taxonomy_vocabulary',
+      'd6_taxonomy_vocabulary_translation',
+    ]);
+  }
+
+  /**
+   * Tests the Drupal 6 i18n taxonomy vocabularies to Drupal 8 migration.
+   */
+  public function testTaxonomyVocabularyTranslation() {
+    $language_manager = \Drupal::service('language_manager');
+    $config = $language_manager->getLanguageConfigOverride('fr', 'taxonomy.vocabulary.vocabulary_1_i_0_');
+    $this->assertSame('fr - vocabulary 1 (i=0)', $config->get('name'));
+    $config = $language_manager->getLanguageConfigOverride('fr', 'taxonomy.vocabulary.vocabulary_2_i_1_');
+    $this->assertSame('fr - vocabulary 2 (i=1)', $config->get('name'));
+    $config = $language_manager->getLanguageConfigOverride('fr', 'taxonomy.vocabulary.vocabulary_3_i_2_');
+    $this->assertSame('fr - vocabulary 3 (i=2)', $config->get('name'));
+    $config = $language_manager->getLanguageConfigOverride('fr', 'taxonomy.vocabulary.vocabulary_name_much_longer_than');
+    $this->assertSame('Nom de vocabulaire beaucoup plus long que trente-deux caractères', $config->get('name'));
+    $config = $language_manager->getLanguageConfigOverride('fr', 'taxonomy.vocabulary.tags');
+    $this->assertSame('fr - Tags', $config->get('name'));
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateTermNodeRevisionTest.php

@@ -14,7 +14,7 @@ class MigrateTermNodeRevisionTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['taxonomy'];
+  public static $modules = ['taxonomy', 'menu_ui'];
 
   /**
    * {@inheritdoc}

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateTermNodeTest.php

@@ -15,7 +15,7 @@ class MigrateTermNodeTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['taxonomy'];
+  public static $modules = ['taxonomy', 'menu_ui'];
 
   /**
    * {@inheritdoc}

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateVocabularyEntityDisplayTest.php

@@ -15,26 +15,56 @@ class MigrateVocabularyEntityDisplayTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['field', 'taxonomy'];
+  public static $modules = ['field', 'taxonomy', 'menu_ui'];
 
   /**
    * {@inheritdoc}
    */
   protected function setUp() {
     parent::setUp();
-    $this->migrateTaxonomy();
+
+    // Execute Dependency Migrations.
+    $this->migrateContentTypes();
+    $this->installEntitySchema('taxonomy_term');
+    $this->executeMigrations([
+      'd6_node_type',
+      'd6_taxonomy_vocabulary',
+      'd6_vocabulary_field',
+      'd6_vocabulary_field_instance',
+    ]);
   }
 
   /**
    * Tests the Drupal 6 vocabulary-node type association to Drupal 8 migration.
    */
   public function testVocabularyEntityDisplay() {
+    $this->executeMigration('d6_vocabulary_entity_display');
+
     // Test that the field exists.
     $component = EntityViewDisplay::load('node.page.default')->getComponent('tags');
     $this->assertIdentical('entity_reference_label', $component['type']);
     $this->assertIdentical(20, $component['weight']);
     // Test the Id map.
-    $this->assertIdentical(array('node', 'article', 'default', 'tags'), $this->getMigration('d6_vocabulary_entity_display')->getIdMap()->lookupDestinationID(array(4, 'article')));
+    $this->assertIdentical(['node', 'article', 'default', 'tags'], $this->getMigration('d6_vocabulary_entity_display')->getIdMap()->lookupDestinationID([4, 'article']));
+  }
+
+  /**
+   * Tests that vocabulary displays are ignored appropriately.
+   *
+   * Vocabulary displays should be ignored when they belong to node types which
+   * were not migrated.
+   */
+  public function testSkipNonExistentNodeType() {
+    // The "story" node type is migrated by d6_node_type but we need to pretend
+    // that it didn't occur, so record that in the map table.
+    $this->mockFailure('d6_node_type', ['type' => 'story']);
+
+    // d6_vocabulary_entity_display should skip over the "story" node type
+    // config because, according to the map table, it didn't occur.
+    $migration = $this->getMigration('d6_vocabulary_entity_display');
+
+    $this->executeMigration($migration);
+    $this->assertNull($migration->getIdMap()->lookupDestinationIds(['type' => 'story'])[0][0]);
   }
 
 }

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateVocabularyEntityFormDisplayTest.php

@@ -15,26 +15,37 @@ class MigrateVocabularyEntityFormDisplayTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['taxonomy'];
+  public static $modules = ['taxonomy', 'menu_ui'];
 
   /**
    * {@inheritdoc}
    */
   protected function setUp() {
     parent::setUp();
-    $this->migrateTaxonomy();
+
+    // Execute Dependency Migrations.
+    $this->migrateContentTypes();
+    $this->installEntitySchema('taxonomy_term');
+    $this->executeMigrations([
+      'd6_taxonomy_vocabulary',
+      'd6_vocabulary_field',
+      'd6_vocabulary_field_instance',
+      'd6_vocabulary_entity_display',
+    ]);
   }
 
   /**
    * Tests the Drupal 6 vocabulary-node type association to Drupal 8 migration.
    */
   public function testVocabularyEntityFormDisplay() {
+    $this->executeMigration('d6_vocabulary_entity_form_display');
+
     // Test that the field exists.
     $component = EntityFormDisplay::load('node.page.default')->getComponent('tags');
     $this->assertIdentical('options_select', $component['type']);
     $this->assertIdentical(20, $component['weight']);
     // Test the Id map.
-    $this->assertIdentical(array('node', 'article', 'default', 'tags'), $this->getMigration('d6_vocabulary_entity_form_display')->getIdMap()->lookupDestinationID(array(4, 'article')));
+    $this->assertIdentical(['node', 'article', 'default', 'tags'], $this->getMigration('d6_vocabulary_entity_form_display')->getIdMap()->lookupDestinationID([4, 'article']));
 
     // Test the term widget tags setting.
     $entity_form_display = EntityFormDisplay::load('node.story.default');
@@ -42,4 +53,23 @@ class MigrateVocabularyEntityFormDisplayTest extends MigrateDrupal6TestBase {
     $this->assertIdentical($entity_form_display->getComponent('vocabulary_2_i_1_')['type'], 'entity_reference_autocomplete_tags');
   }
 
+  /**
+   * Tests that vocabulary displays are ignored appropriately.
+   *
+   * Vocabulary displays should be ignored when they belong to node types which
+   * were not migrated.
+   */
+  public function testSkipNonExistentNodeType() {
+    // The "story" node type is migrated by d6_node_type but we need to pretend
+    // that it didn't occur, so record that in the map table.
+    $this->mockFailure('d6_node_type', ['type' => 'story']);
+
+    // d6_vocabulary_entity_form_display should skip over the "story" node type
+    // config because, according to the map table, it didn't occur.
+    $migration = $this->getMigration('d6_vocabulary_entity_form_display');
+
+    $this->executeMigration($migration);
+    $this->assertNull($migration->getIdMap()->lookupDestinationIds(['type' => 'story'])[0][0]);
+  }
+
 }

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateVocabularyFieldInstanceTest.php

@@ -15,20 +15,30 @@ class MigrateVocabularyFieldInstanceTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['taxonomy'];
+  public static $modules = ['taxonomy', 'menu_ui'];
 
   /**
    * {@inheritdoc}
    */
   protected function setUp() {
     parent::setUp();
-    $this->migrateTaxonomy();
+
+    // Execute Dependency Migrations.
+    $this->migrateContentTypes();
+    $this->installEntitySchema('taxonomy_term');
+    $this->executeMigrations([
+      'd6_node_type',
+      'd6_taxonomy_vocabulary',
+      'd6_vocabulary_field',
+    ]);
   }
 
   /**
    * Tests the Drupal 6 vocabulary-node type association to Drupal 8 migration.
    */
   public function testVocabularyFieldInstance() {
+    $this->executeMigration('d6_vocabulary_field_instance');
+
     // Test that the field exists.
     $field_id = 'node.article.tags';
     $field = FieldConfig::load($field_id);
@@ -48,12 +58,31 @@ class MigrateVocabularyFieldInstanceTest extends MigrateDrupal6TestBase {
     $this->assertIdentical(['tags'], $settings['handler_settings']['target_bundles'], 'The target_bundles handler setting is correct.');
     $this->assertIdentical(TRUE, $settings['handler_settings']['auto_create'], 'The "auto_create" setting is correct.');
 
-    $this->assertIdentical(array('node', 'article', 'tags'), $this->getMigration('d6_vocabulary_field_instance')->getIdMap()->lookupDestinationID(array(4, 'article')));
+    $this->assertIdentical(['node', 'article', 'tags'], $this->getMigration('d6_vocabulary_field_instance')->getIdMap()->lookupDestinationID([4, 'article']));
 
-    // Test the the field vocabulary_1_i_0_
+    // Test the the field vocabulary_1_i_0_.
     $field_id = 'node.story.vocabulary_1_i_0_';
     $field = FieldConfig::load($field_id);
     $this->assertFalse($field->isRequired(), 'Field is not required');
   }
 
+  /**
+   * Tests that vocabulary field instances are ignored appropriately.
+   *
+   * Vocabulary field instances should be ignored when they belong to node
+   * types which were not migrated.
+   */
+  public function testSkipNonExistentNodeType() {
+    // The "story" node type is migrated by d6_node_type but we need to pretend
+    // that it didn't occur, so record that in the map table.
+    $this->mockFailure('d6_node_type', ['type' => 'story']);
+
+    // d6_vocabulary_field_instance should skip over the "story" node type
+    // config because, according to the map table, it didn't occur.
+    $migration = $this->getMigration('d6_vocabulary_field_instance');
+
+    $this->executeMigration($migration);
+    $this->assertNull($migration->getIdMap()->lookupDestinationIds(['type' => 'story'])[0][0]);
+  }
+
 }

core/modules/taxonomy/tests/src/Kernel/Migrate/d6/MigrateVocabularyFieldTest.php

@@ -15,7 +15,7 @@ class MigrateVocabularyFieldTest extends MigrateDrupal6TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['taxonomy'];
+  public static $modules = ['taxonomy', 'menu_ui'];
 
   /**
    * {@inheritdoc}
@@ -39,7 +39,7 @@ class MigrateVocabularyFieldTest extends MigrateDrupal6TestBase {
     $this->assertIdentical('taxonomy_term', $settings['target_type'], "Target type is correct.");
     $this->assertIdentical(1, $field_storage->getCardinality(), "Field cardinality in 1.");
 
-    $this->assertIdentical(array('node', 'tags'), $this->getMigration('d6_vocabulary_field')->getIdMap()->lookupDestinationID(array(4)), "Test IdMap");
+    $this->assertIdentical(['node', 'tags'], $this->getMigration('d6_vocabulary_field')->getIdMap()->lookupDestinationID([4]), "Test IdMap");
   }
 
 }

core/modules/taxonomy/tests/src/Kernel/Migrate/d7/MigrateNodeTaxonomyTest.php

@@ -14,17 +14,18 @@ use Drupal\node\NodeInterface;
  */
 class MigrateNodeTaxonomyTest extends MigrateDrupal7TestBase {
 
-  public static $modules = array(
+  public static $modules = [
     'datetime',
     'field',
     'filter',
     'image',
     'link',
+    'menu_ui',
     'node',
     'taxonomy',
     'telephone',
     'text',
-  );
+  ];
 
   /**
    * {@inheritdoc}
@@ -40,21 +41,21 @@ class MigrateNodeTaxonomyTest extends MigrateDrupal7TestBase {
 
     $this->executeMigration('d7_node_type');
 
-    FieldStorageConfig::create(array(
+    FieldStorageConfig::create([
       'type' => 'entity_reference',
       'field_name' => 'field_tags',
       'entity_type' => 'node',
-      'settings' => array(
+      'settings' => [
         'target_type' => 'taxonomy_term',
-      ),
+      ],
       'cardinality' => FieldStorageConfigInterface::CARDINALITY_UNLIMITED,
-    ))->save();
+    ])->save();
 
-    FieldConfig::create(array(
+    FieldConfig::create([
       'entity_type' => 'node',
       'field_name' => 'field_tags',
       'bundle' => 'article',
-    ))->save();
+    ])->save();
 
     $this->executeMigrations([
       'd7_taxonomy_vocabulary',

core/modules/taxonomy/tests/src/Kernel/Migrate/d7/MigrateTaxonomyTermTest.php

@@ -13,7 +13,17 @@ use Drupal\taxonomy\TermInterface;
  */
 class MigrateTaxonomyTermTest extends MigrateDrupal7TestBase {
 
-  public static $modules = array('taxonomy', 'text');
+  public static $modules = [
+    'comment',
+    'datetime',
+    'image',
+    'link',
+    'menu_ui',
+    'node',
+    'taxonomy',
+    'telephone',
+    'text',
+  ];
 
   /**
    * The cached taxonomy tree items, keyed by vid and tid.
@@ -28,7 +38,16 @@ class MigrateTaxonomyTermTest extends MigrateDrupal7TestBase {
   protected function setUp() {
     parent::setUp();
     $this->installEntitySchema('taxonomy_term');
-    $this->executeMigrations(['d7_taxonomy_vocabulary', 'd7_taxonomy_term']);
+    $this->installConfig(static::$modules);
+
+    $this->executeMigrations([
+      'd7_node_type',
+      'd7_comment_type',
+      'd7_field',
+      'd7_taxonomy_vocabulary',
+      'd7_field_instance',
+      'd7_taxonomy_term'
+    ]);
   }
 
   /**
@@ -48,8 +67,12 @@ class MigrateTaxonomyTermTest extends MigrateDrupal7TestBase {
    *   The weight the migrated entity should have.
    * @param array $expected_parents
    *   The parent terms the migrated entity should have.
+   * @param int $expected_field_integer_value
+   *   The value the migrated entity field should have.
+   * @param int $expected_term_reference_tid
+   *   The term reference id the migrated entity field should have.
    */
-  protected function assertEntity($id, $expected_label, $expected_vid, $expected_description = '', $expected_format = NULL, $expected_weight = 0, $expected_parents = []) {
+  protected function assertEntity($id, $expected_label, $expected_vid, $expected_description = '', $expected_format = NULL, $expected_weight = 0, $expected_parents = [], $expected_field_integer_value = NULL, $expected_term_reference_tid = NULL) {
     /** @var \Drupal\taxonomy\TermInterface $entity */
     $entity = Term::load($id);
     $this->assertTrue($entity instanceof TermInterface);
@@ -60,6 +83,14 @@ class MigrateTaxonomyTermTest extends MigrateDrupal7TestBase {
     $this->assertEqual($expected_weight, $entity->getWeight());
     $this->assertIdentical($expected_parents, $this->getParentIDs($id));
     $this->assertHierarchy($expected_vid, $id, $expected_parents);
+    if (!is_null($expected_field_integer_value)) {
+      $this->assertTrue($entity->hasField('field_integer'));
+      $this->assertEquals($expected_field_integer_value, $entity->field_integer->value);
+    }
+    if (!is_null($expected_term_reference_tid)) {
+      $this->assertTrue($entity->hasField('field_integer'));
+      $this->assertEquals($expected_term_reference_tid, $entity->field_term_reference->target_id);
+    }
   }
 
   /**
@@ -67,9 +98,9 @@ class MigrateTaxonomyTermTest extends MigrateDrupal7TestBase {
    */
   public function testTaxonomyTerms() {
     $this->assertEntity(1, 'General discussion', 'forums', '', NULL, 2);
-    $this->assertEntity(2, 'Term1', 'test_vocabulary', 'The first term.', 'filtered_html');
+    $this->assertEntity(2, 'Term1', 'test_vocabulary', 'The first term.', 'filtered_html', 0, [], NULL, 3);
     $this->assertEntity(3, 'Term2', 'test_vocabulary', 'The second term.', 'filtered_html');
-    $this->assertEntity(4, 'Term3', 'test_vocabulary', 'The third term.', 'full_html', 0, [3]);
+    $this->assertEntity(4, 'Term3', 'test_vocabulary', 'The third term.', 'full_html', 0, [3], 6);
     $this->assertEntity(5, 'Custom Forum', 'forums', 'Where the cool kids are.', NULL, 3);
     $this->assertEntity(6, 'Games', 'forums', '', NULL, 4);
     $this->assertEntity(7, 'Minecraft', 'forums', '', NULL, 1, [6]);

core/modules/taxonomy/tests/src/Kernel/Migrate/d7/MigrateTaxonomyVocabularyTest.php

@@ -16,7 +16,7 @@ class MigrateTaxonomyVocabularyTest extends MigrateDrupal7TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = array('taxonomy');
+  public static $modules = ['taxonomy'];
 
   /**
    * {@inheritdoc}
@@ -54,9 +54,10 @@ class MigrateTaxonomyVocabularyTest extends MigrateDrupal7TestBase {
    * Tests the Drupal 7 taxonomy vocabularies to Drupal 8 migration.
    */
   public function testTaxonomyVocabulary() {
-    $this->assertEntity('tags', 'Tags', 'Use tags to group articles on similar topics into categories.', TAXONOMY_HIERARCHY_DISABLED, 0);
-    $this->assertEntity('forums', 'Forums', 'Forum navigation vocabulary', TAXONOMY_HIERARCHY_SINGLE, -10);
-    $this->assertEntity('test_vocabulary', 'Test Vocabulary', 'This is the vocabulary description', TAXONOMY_HIERARCHY_SINGLE, 0);
+    $this->assertEntity('tags', 'Tags', 'Use tags to group articles on similar topics into categories.', VocabularyInterface::HIERARCHY_DISABLED, 0);
+    $this->assertEntity('forums', 'Forums', 'Forum navigation vocabulary', VocabularyInterface::HIERARCHY_SINGLE, -10);
+    $this->assertEntity('test_vocabulary', 'Test Vocabulary', 'This is the vocabulary description', VocabularyInterface::HIERARCHY_SINGLE, 0);
+    $this->assertEntity('vocabulary_name_much_longer_than', 'vocabulary name much longer than thirty two characters', 'description of vocabulary name much longer than thirty two characters', VocabularyInterface::HIERARCHY_SINGLE, 0);
   }
 
 }

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d6/TermNodeTest.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d6;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests d6_term_node source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d6\TermNode
+ * @group taxonomy
+ */
+class TermNodeTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['source_data']['term_node'] = [
+      [
+        'nid' => '1',
+        'vid' => '1',
+        'tid' => '1',
+      ],
+      [
+        'nid' => '1',
+        'vid' => '1',
+        'tid' => '4',
+      ],
+      [
+        'nid' => '1',
+        'vid' => '1',
+        'tid' => '5',
+      ],
+    ];
+    $tests[0]['source_data']['node'] = [
+      [
+        'nid' => '1',
+        'vid' => '1',
+        'type' => 'story',
+        'language' => '',
+        'title' => 'Test title',
+        'uid' => '1',
+        'status' => '1',
+        'created' => '1388271197',
+        'changed' => '1420861423',
+        'comment' => '0',
+        'promote' => '0',
+        'moderate' => '0',
+        'sticky' => '0',
+        'tnid' => '0',
+        'translate' => '0',
+      ],
+    ];
+    $tests[0]['source_data']['term_data'] = [
+      [
+        'tid' => '1',
+        'vid' => '3',
+        'name' => 'term 1 of vocabulary 3',
+        'description' => 'description of term 1 of vocabulary 3',
+        'weight' => '0',
+      ],
+      [
+        'tid' => '4',
+        'vid' => '3',
+        'name' => 'term 4 of vocabulary 3',
+        'description' => 'description of term 4 of vocabulary 3',
+        'weight' => '6',
+      ],
+      [
+        'tid' => '5',
+        'vid' => '3',
+        'name' => 'term 5 of vocabulary 3',
+        'description' => 'description of term 5 of vocabulary 3',
+        'weight' => '7',
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'nid' => 1,
+        'vid' => 1,
+        'type' => 'story',
+        'tid' => [1, 4, 5],
+      ],
+    ];
+
+    // Set default value for expected count.
+    $tests[0]['expected_count'] = NULL;
+
+    // Set plugin configuration.
+    $tests[0]['configuration'] = [
+      'vid' => 3,
+    ];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d6/TermSourceWithVocabularyFilterTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d6;
+
+/**
+ * Tests the taxonomy term source with vocabulary filter.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d6\Term
+ * @group taxonomy
+ */
+class TermSourceWithVocabularyFilterTest extends TermTest {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    // Get the source data from parent.
+    $tests = parent::providerSource();
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+      ],
+    ];
+
+    // We know there are two rows with vid == 5.
+    $tests[0]['expected_count'] = 2;
+
+    // Set up source plugin configuration.
+    $tests[0]['configuration'] = [
+      'bundle' => [5],
+    ];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d6/TermTest.php

@@ -0,0 +1,218 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d6;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests taxonomy term source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d6\Term
+ * @group taxonomy
+ */
+class TermTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['source_data']['term_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 2,
+        'vid' => 6,
+        'name' => 'name value 2',
+        'description' => 'description value 2',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 3,
+        'vid' => 6,
+        'name' => 'name value 3',
+        'description' => 'description value 3',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+      ],
+      [
+        'tid' => 5,
+        'vid' => 6,
+        'name' => 'name value 5',
+        'description' => 'description value 5',
+        'weight' => 1,
+      ],
+      [
+        'tid' => 6,
+        'vid' => 6,
+        'name' => 'name value 6',
+        'description' => 'description value 6',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 7,
+        'vid' => 3,
+        'name' => 'name value 7',
+        'description' => 'description value 7',
+        'weight' => 0,
+      ],
+    ];
+    $tests[0]['source_data']['term_hierarchy'] = [
+      [
+        'tid' => 1,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 2,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 3,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 4,
+        'parent' => 1,
+      ],
+      [
+        'tid' => 5,
+        'parent' => 2,
+      ],
+      [
+        'tid' => 6,
+        'parent' => 3,
+      ],
+      [
+        'tid' => 6,
+        'parent' => 2,
+      ],
+      [
+        'tid' => 7,
+        'parent' => 0,
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 2,
+        'vid' => 6,
+        'name' => 'name value 2',
+        'description' => 'description value 2',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 3,
+        'vid' => 6,
+        'name' => 'name value 3',
+        'description' => 'description value 3',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+      ],
+      [
+        'tid' => 5,
+        'vid' => 6,
+        'name' => 'name value 5',
+        'description' => 'description value 5',
+        'weight' => 1,
+        'parent' => [2],
+      ],
+      [
+        'tid' => 6,
+        'vid' => 6,
+        'name' => 'name value 6',
+        'description' => 'description value 6',
+        'weight' => 0,
+        'parent' => [3, 2],
+      ],
+      [
+        'tid' => 7,
+        'vid' => 3,
+        'name' => 'name value 7',
+        'description' => 'description value 7',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+    ];
+
+    $tests[0]['expected_count'] = NULL;
+    // Empty configuration will return terms for all vocabularies.
+    $tests[0]['configuration'] = [];
+
+    // Change configuration to get one vocabulary, 5.
+    $tests[1]['source_data'] = $tests[0]['source_data'];
+    $tests[1]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+      ],
+    ];
+    $tests[1]['expected_count'] = NULL;
+    $tests[1]['configuration']['bundle'] = ['5'];
+
+    // Same as previous test, but with configuration vocabulary as a string
+    // instead of an array.
+    $tests[2]['source_data'] = $tests[0]['source_data'];
+    $tests[2]['expected_data'] = $tests[1]['expected_data'];
+    $tests[2]['expected_count'] = NULL;
+    $tests[2]['configuration']['bundle'] = '5';
+
+    // Change configuration to get two vocabularies, 5 and 6.
+    $tests[3]['source_data'] = $tests[0]['source_data'];
+    $tests[3]['expected_data'] = $tests[0]['expected_data'];
+    // Remove the last element because it is for vid 3.
+    array_pop($tests[3]['expected_data']);
+    $tests[3]['expected_count'] = NULL;
+    $tests[3]['configuration']['bundle'] = ['5', '6'];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d6/TermTranslationTest.php

@@ -0,0 +1,206 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d6;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests taxonomy term source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d6\Term
+ * @group taxonomy
+ */
+class TermTranslationTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['source_data']['term_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 2,
+        'vid' => 6,
+        'name' => 'name value 2',
+        'description' => 'description value 2',
+        'weight' => 0,
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 3,
+        'vid' => 6,
+        'name' => 'name value 3',
+        'description' => 'description value 3',
+        'weight' => 0,
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 5,
+        'vid' => 6,
+        'name' => 'name value 5',
+        'description' => 'description value 5',
+        'weight' => 1,
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 6,
+        'vid' => 6,
+        'name' => 'name value 6',
+        'description' => 'description value 6',
+        'weight' => 0,
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 10,
+        'vid' => 6,
+        'name' => 'zu - name value 2',
+        'description' => 'zu - description value 2',
+        'weight' => 0,
+        'language' => 'zu',
+        'trid' => 0,
+      ],
+    ];
+    $tests[0]['source_data']['term_hierarchy'] = [
+      [
+        'tid' => 1,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 2,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 3,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 4,
+        'parent' => 1,
+      ],
+      [
+        'tid' => 5,
+        'parent' => 2,
+      ],
+      [
+        'tid' => 6,
+        'parent' => 3,
+      ],
+      [
+        'tid' => 6,
+        'parent' => 2,
+      ],
+      [
+        'tid' => 10,
+        'parent' => 0,
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 10,
+        'vid' => 6,
+        'name' => 'zu - name value 2',
+        'description' => 'zu - description value 2',
+        'weight' => 0,
+        'parent' => [0],
+        'language' => 'zu',
+        'trid' => 0,
+      ],
+      [
+        'tid' => 2,
+        'vid' => 6,
+        'name' => 'name value 2',
+        'description' => 'description value 2',
+        'weight' => 0,
+        'parent' => [0],
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 3,
+        'vid' => 6,
+        'name' => 'name value 3',
+        'description' => 'description value 3',
+        'weight' => 0,
+        'parent' => [0],
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 5,
+        'vid' => 6,
+        'name' => 'name value 5',
+        'description' => 'description value 5',
+        'weight' => 1,
+        'parent' => [2],
+        'language' => NULL,
+        'trid' => 0,
+      ],
+      [
+        'tid' => 6,
+        'vid' => 6,
+        'name' => 'name value 6',
+        'description' => 'description value 6',
+        'weight' => 0,
+        'parent' => [3, 2],
+        'language' => NULL,
+        'trid' => 0,
+      ],
+    ];
+
+    $tests[0]['expected_count'] = NULL;
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d6/VocabularyTest.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d6;
+
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests D6 vocabulary source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d6\Vocabulary
+ * @group taxonomy
+ */
+class VocabularyTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['source_data']['vocabulary'] = [
+      [
+        'vid' => 1,
+        'name' => 'Tags',
+        'description' => 'Tags description.',
+        'help' => 1,
+        'relations' => 0,
+        'hierarchy' => 0,
+        'multiple' => 0,
+        'required' => 0,
+        'tags' => 1,
+        'module' => 'taxonomy',
+        'weight' => 0,
+      ],
+      [
+        'vid' => 2,
+        'name' => 'Categories',
+        'description' => 'Categories description.',
+        'help' => 1,
+        'relations' => 1,
+        'hierarchy' => 1,
+        'multiple' => 0,
+        'required' => 1,
+        'tags' => 0,
+        'module' => 'taxonomy',
+        'weight' => 0,
+      ],
+    ];
+    $tests[0]['source_data']['vocabulary_node_types'] = [
+      [
+        'vid' => 1,
+        'type' => 'page',
+      ],
+      [
+        'vid' => 1,
+        'type' => 'article',
+      ],
+      [
+        'vid' => 2,
+        'type' => 'article',
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'vid' => 1,
+        'name' => 'Tags',
+        'description' => 'Tags description.',
+        'help' => 1,
+        'relations' => 0,
+        'hierarchy' => 0,
+        'multiple' => 0,
+        'required' => 0,
+        'tags' => 1,
+        'module' => 'taxonomy',
+        'weight' => 0,
+        'node_types' => ['page', 'article'],
+        'cardinality' => FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED,
+      ],
+      [
+        'vid' => 2,
+        'name' => 'Categories',
+        'description' => 'Categories description.',
+        'help' => 1,
+        'relations' => 1,
+        'hierarchy' => 1,
+        'multiple' => 0,
+        'required' => 1,
+        'tags' => 0,
+        'module' => 'taxonomy',
+        'weight' => 0,
+        'node_types' => ['article'],
+        'cardinality' => 1,
+      ],
+    ];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d6/VocabularyTranslationTest.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d6;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests D6 i18n vocabulary source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d6\VocabularyTranslation
+ * @group taxonomy
+ */
+class VocabularyTranslationTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0][0]['i18n_strings'] = [
+      [
+        'lid' => 1,
+        'objectid' => 1,
+        'type' => 'vocabulary',
+        'property' => 'name',
+        'objectindex' => 1,
+        'format' => 0,
+      ],
+      [
+        'lid' => 2,
+        'objectid' => 2,
+        'type' => 'vocabulary',
+        'property' => 'name',
+        'objectindex' => 2,
+        'format' => 0,
+      ],
+    ];
+
+    $tests[0][0]['locales_target'] = [
+      [
+        'lid' => 1,
+        'language' => 'fr',
+        'translation' => 'fr - vocabulary 1',
+        'plid' => 0,
+        'plural' => 0,
+        'i18n_status' => 0,
+      ],
+      [
+        'lid' => 2,
+        'language' => 'fr',
+        'translation' => 'fr - vocabulary 2',
+        'plid' => 0,
+        'plural' => 0,
+        'i18n_status' => 0,
+      ],
+    ];
+
+    $tests[0][0]['vocabulary'] = [
+      [
+        'vid' => 1,
+        'name' => 'vocabulary 1',
+        'description' => 'description of vocabulary 1',
+        'help' => 1,
+        'relations' => 1,
+        'hierarchy' => 1,
+        'multiple' => 0,
+        'required' => 0,
+        'tags' => 0,
+        'module' => 'taxonomy',
+        'weight' => 4,
+        'language' => '',
+      ],
+      [
+        'vid' => 2,
+        'name' => 'vocabulary 2',
+        'description' => 'description of vocabulary 2',
+        'help' => 1,
+        'relations' => 1,
+        'hierarchy' => 1,
+        'multiple' => 0,
+        'required' => 0,
+        'tags' => 0,
+        'module' => 'taxonomy',
+        'weight' => 5,
+        'language' => '',
+      ],
+    ];
+
+    $tests[0]['expected_results'] = [
+      [
+        'vid' => 1,
+        'name' => 'vocabulary 1',
+        'description' => 'description of vocabulary 1',
+        'lid' => '1',
+        'type' => 'vocabulary',
+        'property' => 'name',
+        'objectid' => '1',
+        'lt_lid' => '1',
+        'translation' => 'fr - vocabulary 1',
+        'language' => 'fr',
+      ],
+      [
+        'vid' => 2,
+        'name' => 'vocabulary 2',
+        'description' => 'description of vocabulary 2',
+        'lid' => '2',
+        'type' => 'vocabulary',
+        'property' => 'name',
+        'objectid' => '2',
+        'lt_lid' => '2',
+        'translation' => 'fr - vocabulary 2',
+        'language' => 'fr',
+      ],
+    ];
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d7/TermSourceWithVocabularyFilterTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d7;
+
+/**
+ * Tests the taxonomy term source with vocabulary filter.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d7\Term
+ * @group taxonomy
+ */
+class TermSourceWithVocabularyFilterTest extends TermTest {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    // Get the source data from parent.
+    $tests = parent::providerSource();
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+      ],
+    ];
+
+    // We know there are two rows with machine_name == 'tags'.
+    $tests[0]['expected_count'] = 2;
+
+    // Set up source plugin configuration.
+    $tests[0]['configuration'] = [
+      'bundle' => ['tags'],
+    ];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d7/TermTest.php

@@ -0,0 +1,258 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d7;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests taxonomy term source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d7\Term
+ * @group taxonomy
+ */
+class TermTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['source_data']['taxonomy_term_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 2,
+        'vid' => 6,
+        'name' => 'name value 2',
+        'description' => 'description value 2',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 3,
+        'vid' => 6,
+        'name' => 'name value 3',
+        'description' => 'description value 3',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+      ],
+      [
+        'tid' => 5,
+        'vid' => 6,
+        'name' => 'name value 5',
+        'description' => 'description value 5',
+        'weight' => 1,
+      ],
+      [
+        'tid' => 6,
+        'vid' => 6,
+        'name' => 'name value 6',
+        'description' => 'description value 6',
+        'weight' => 0,
+      ],
+      [
+        'tid' => 7,
+        'vid' => 3,
+        'name' => 'name value 7',
+        'description' => 'description value 7',
+        'weight' => 0,
+      ],
+    ];
+    $tests[0]['source_data']['taxonomy_term_hierarchy'] = [
+      [
+        'tid' => 1,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 2,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 3,
+        'parent' => 0,
+      ],
+      [
+        'tid' => 4,
+        'parent' => 1,
+      ],
+      [
+        'tid' => 5,
+        'parent' => 2,
+      ],
+      [
+        'tid' => 6,
+        'parent' => 3,
+      ],
+      [
+        'tid' => 6,
+        'parent' => 2,
+      ],
+      [
+        'tid' => 7,
+        'parent' => 0,
+      ],
+    ];
+    $tests[0]['source_data']['taxonomy_vocabulary'] = [
+      [
+        'vid' => 5,
+        'machine_name' => 'tags',
+      ],
+      [
+        'vid' => 6,
+        'machine_name' => 'categories',
+      ],
+    ];
+    $tests[0]['source_data']['field_config_instance'] = [
+      [
+        'field_name' => 'field_term_field',
+        'entity_type' => 'taxonomy_term',
+        'bundle' => 'tags',
+        'deleted' => 0,
+      ],
+      [
+        'field_name' => 'field_term_field',
+        'entity_type' => 'taxonomy_term',
+        'bundle' => 'categories',
+        'deleted' => 0,
+      ],
+    ];
+    $tests[0]['source_data']['field_data_field_term_field'] = [
+      [
+        'entity_type' => 'taxonomy_term',
+        'bundle' => 'tags',
+        'deleted' => 0,
+        'entity_id' => 1,
+        'delta' => 0,
+      ],
+      [
+        'entity_type' => 'taxonomy_term',
+        'bundle' => 'categories',
+        'deleted' => 0,
+        'entity_id' => 1,
+        'delta' => 0,
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 2,
+        'vid' => 6,
+        'name' => 'name value 2',
+        'description' => 'description value 2',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 3,
+        'vid' => 6,
+        'name' => 'name value 3',
+        'description' => 'description value 3',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+      ],
+      [
+        'tid' => 5,
+        'vid' => 6,
+        'name' => 'name value 5',
+        'description' => 'description value 5',
+        'weight' => 1,
+        'parent' => [2],
+      ],
+      [
+        'tid' => 6,
+        'vid' => 6,
+        'name' => 'name value 6',
+        'description' => 'description value 6',
+        'weight' => 0,
+        'parent' => [3, 2],
+      ],
+      [
+        'tid' => 7,
+        'vid' => 3,
+        'name' => 'name value 7',
+        'description' => 'description value 7',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+    ];
+
+    $tests[0]['expected_count'] = NULL;
+    // Empty configuration will return terms for all vocabularies.
+    $tests[0]['configuration'] = [];
+
+    // Change configuration to get one vocabulary, "tags".
+    $tests[1]['source_data'] = $tests[0]['source_data'];
+    $tests[1]['expected_data'] = [
+      [
+        'tid' => 1,
+        'vid' => 5,
+        'name' => 'name value 1',
+        'description' => 'description value 1',
+        'weight' => 0,
+        'parent' => [0],
+      ],
+      [
+        'tid' => 4,
+        'vid' => 5,
+        'name' => 'name value 4',
+        'description' => 'description value 4',
+        'weight' => 1,
+        'parent' => [1],
+      ],
+    ];
+    $tests[1]['expected_count'] = NULL;
+    $tests[1]['configuration']['bundle'] = ['tags'];
+
+    // Same as previous test, but with configuration vocabulary as a string
+    // instead of an array.
+    $tests[2]['source_data'] = $tests[0]['source_data'];
+    $tests[2]['expected_data'] = $tests[1]['expected_data'];
+    $tests[2]['expected_count'] = NULL;
+    $tests[2]['configuration']['bundle'] = 'tags';
+
+    // Change configuration to get two vocabularies, "tags" and "categories".
+    $tests[3]['source_data'] = $tests[0]['source_data'];
+    $tests[3]['expected_data'] = $tests[0]['expected_data'];
+    // Remove the last element because it is for vid 3.
+    array_pop($tests[3]['expected_data']);
+    $tests[3]['expected_count'] = NULL;
+    $tests[3]['configuration']['bundle'] = ['tags', 'categories'];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/Plugin/migrate/source/d7/VocabularyTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Kernel\Plugin\migrate\source\d7;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests D7 vocabulary source plugin.
+ *
+ * @covers \Drupal\taxonomy\Plugin\migrate\source\d7\Vocabulary
+ * @group taxonomy
+ */
+class VocabularyTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['taxonomy', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['source_data']['taxonomy_vocabulary'] = [
+      [
+        'vid' => 1,
+        'name' => 'Tags',
+        'description' => 'Tags description.',
+        'hierarchy' => 0,
+        'module' => 'taxonomy',
+        'weight' => 0,
+        'machine_name' => 'tags',
+      ],
+      [
+        'vid' => 2,
+        'name' => 'Categories',
+        'description' => 'Categories description.',
+        'hierarchy' => 1,
+        'module' => 'taxonomy',
+        'weight' => 0,
+        'machine_name' => 'categories',
+      ],
+    ];
+
+    // The expected results.
+    $tests[0]['expected_data'] = $tests[0]['source_data']['taxonomy_vocabulary'];
+
+    return $tests;
+  }
+
+}

core/modules/taxonomy/tests/src/Kernel/TermKernelTest.php

@@ -4,7 +4,7 @@ namespace Drupal\Tests\taxonomy\Kernel;
 
 use Drupal\taxonomy\Entity\Term;
 use Drupal\KernelTests\KernelTestBase;
-use Drupal\taxonomy\Tests\TaxonomyTestTrait;
+use Drupal\Tests\taxonomy\Functional\TaxonomyTestTrait;
 
 /**
  * Kernel tests for taxonomy term functions.
@@ -18,14 +18,14 @@ class TermKernelTest extends KernelTestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = array( 'filter', 'taxonomy', 'text', 'user' );
+  public static $modules = [ 'filter', 'taxonomy', 'text', 'user' ];
 
   /**
    * {@inheritdoc}
    */
   protected function setUp() {
     parent::setUp();
-    $this->installConfig(array('filter'));
+    $this->installConfig(['filter']);
     $this->installEntitySchema('taxonomy_term');
   }
 
@@ -38,11 +38,11 @@ class TermKernelTest extends KernelTestBase {
     $valid_term = $this->createTerm($vocabulary);
     // Delete a valid term.
     $valid_term->delete();
-    $terms = entity_load_multiple_by_properties('taxonomy_term', array('vid' => $vocabulary->id()));
+    $terms = entity_load_multiple_by_properties('taxonomy_term', ['vid' => $vocabulary->id()]);
     $this->assertTrue(empty($terms), 'Vocabulary is empty after deletion');
 
     // Delete an invalid term. Should not throw any notices.
-    entity_delete_multiple('taxonomy_term', array(42));
+    entity_delete_multiple('taxonomy_term', [42]);
   }
 
   /**
@@ -53,18 +53,18 @@ class TermKernelTest extends KernelTestBase {
     $parent_term1 = $this->createTerm($vocabulary);
     $parent_term2 = $this->createTerm($vocabulary);
     $child_term = $this->createTerm($vocabulary);
-    $child_term->parent = array($parent_term1->id(), $parent_term2->id());
+    $child_term->parent = [$parent_term1->id(), $parent_term2->id()];
     $child_term->save();
     $child_term_id = $child_term->id();
 
     $parent_term1->delete();
     $term_storage = $this->container->get('entity.manager')->getStorage('taxonomy_term');
-    $term_storage->resetCache(array($child_term_id));
+    $term_storage->resetCache([$child_term_id]);
     $child_term = Term::load($child_term_id);
     $this->assertTrue(!empty($child_term), 'Child term is not deleted if only one of its parents is removed.');
 
     $parent_term2->delete();
-    $term_storage->resetCache(array($child_term_id));
+    $term_storage->resetCache([$child_term_id]);
     $child_term = Term::load($child_term_id);
     $this->assertTrue(empty($child_term), 'Child term is deleted if all of its parents are removed.');
   }
@@ -75,7 +75,7 @@ class TermKernelTest extends KernelTestBase {
   public function testTaxonomyVocabularyTree() {
     // Create a new vocabulary with 6 terms.
     $vocabulary = $this->createVocabulary();
-    $term = array();
+    $term = [];
     for ($i = 0; $i < 6; $i++) {
       $term[$i] = $this->createTerm($vocabulary);
     }
@@ -90,13 +90,13 @@ class TermKernelTest extends KernelTestBase {
     $term[1]->save();
 
     // $term[2] is a child of 1 and 5.
-    $term[2]->parent = array($term[1]->id(), $term[5]->id());
+    $term[2]->parent = [$term[1]->id(), $term[5]->id()];
     $term[2]->save();
     // $term[3] is a child of 2.
-    $term[3]->parent = array($term[2]->id());
+    $term[3]->parent = [$term[2]->id()];
     $term[3]->save();
     // $term[5] is a child of 4.
-    $term[5]->parent = array($term[4]->id());
+    $term[5]->parent = [$term[4]->id()];
     $term[5]->save();
 
     /**

core/modules/taxonomy/tests/src/Kernel/TermValidationTest.php

@@ -16,7 +16,7 @@ class TermValidationTest extends EntityKernelTestBase {
    *
    * @var array
    */
-  public static $modules = array('taxonomy');
+  public static $modules = ['taxonomy'];
 
   /**
    * {@inheritdoc}
@@ -30,14 +30,14 @@ class TermValidationTest extends EntityKernelTestBase {
    * Tests the term validation constraints.
    */
   public function testValidation() {
-    $this->entityManager->getStorage('taxonomy_vocabulary')->create(array(
+    $this->entityManager->getStorage('taxonomy_vocabulary')->create([
       'vid' => 'tags',
       'name' => 'Tags',
-    ))->save();
-    $term = $this->entityManager->getStorage('taxonomy_term')->create(array(
+    ])->save();
+    $term = $this->entityManager->getStorage('taxonomy_term')->create([
       'name' => 'test',
       'vid' => 'tags',
-    ));
+    ]);
     $violations = $term->validate();
     $this->assertEqual(count($violations), 0, 'No violations when validating a default term.');
 
@@ -46,7 +46,7 @@ class TermValidationTest extends EntityKernelTestBase {
     $this->assertEqual(count($violations), 1, 'Violation found when name is too long.');
     $this->assertEqual($violations[0]->getPropertyPath(), 'name.0.value');
     $field_label = $term->get('name')->getFieldDefinition()->getLabel();
-    $this->assertEqual($violations[0]->getMessage(), t('%name: may not be longer than @max characters.', array('%name' => $field_label, '@max' => 255)));
+    $this->assertEqual($violations[0]->getMessage(), t('%name: may not be longer than @max characters.', ['%name' => $field_label, '@max' => 255]));
 
     $term->set('name', NULL);
     $violations = $term->validate();
@@ -58,7 +58,7 @@ class TermValidationTest extends EntityKernelTestBase {
     $term->set('parent', 9999);
     $violations = $term->validate();
     $this->assertEqual(count($violations), 1, 'Violation found when term parent is invalid.');
-    $this->assertEqual($violations[0]->getMessage(), format_string('The referenced entity (%type: %id) does not exist.', array('%type' => 'taxonomy_term', '%id' => 9999)));
+    $this->assertEqual($violations[0]->getMessage(), format_string('The referenced entity (%type: %id) does not exist.', ['%type' => 'taxonomy_term', '%id' => 9999]));
 
     $term->set('parent', 0);
     $violations = $term->validate();

core/modules/taxonomy/tests/src/Unit/Menu/TaxonomyLocalTasksTest.php

@@ -12,7 +12,7 @@ use Drupal\Tests\Core\Menu\LocalTaskIntegrationTestBase;
 class TaxonomyLocalTasksTest extends LocalTaskIntegrationTestBase {
 
   protected function setUp() {
-    $this->directoryList = array('taxonomy' => 'core/modules/taxonomy');
+    $this->directoryList = ['taxonomy' => 'core/modules/taxonomy'];
     parent::setUp();
   }
 
@@ -21,10 +21,10 @@ class TaxonomyLocalTasksTest extends LocalTaskIntegrationTestBase {
    *
    * @dataProvider getTaxonomyPageRoutes
    */
-  public function testTaxonomyPageLocalTasks($route, $subtask = array()) {
-    $tasks = array(
-      0 => array('entity.taxonomy_term.canonical', 'entity.taxonomy_term.edit_form'),
-    );
+  public function testTaxonomyPageLocalTasks($route, $subtask = []) {
+    $tasks = [
+      0 => ['entity.taxonomy_term.canonical', 'entity.taxonomy_term.edit_form'],
+    ];
     if ($subtask) $tasks[] = $subtask;
     $this->assertLocalTasks($route, $tasks);
   }
@@ -33,10 +33,10 @@ class TaxonomyLocalTasksTest extends LocalTaskIntegrationTestBase {
    * Provides a list of routes to test.
    */
   public function getTaxonomyPageRoutes() {
-    return array(
-      array('entity.taxonomy_term.canonical'),
-      array('entity.taxonomy_term.edit_form'),
-    );
+    return [
+      ['entity.taxonomy_term.canonical'],
+      ['entity.taxonomy_term.edit_form'],
+    ];
   }
 
 }