first commit

core/modules/link/tests/modules/link_test_base_field/link_test_base_field.info.yml

@@ -0,0 +1,12 @@
+name: Link test base field
+description: Tests link field as an optional base field
+type: module
+hidden: true
+dependencies:
+  - drupal:link
+  - drupal:entity_test
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/link/tests/modules/link_test_base_field/link_test_base_field.module

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * @file
+ * Contains main module functions.
+ */
+
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\Core\Field\BaseFieldDefinition;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\link\LinkItemInterface;
+
+/**
+ * Implements hook_entity_base_field_info().
+ */
+function link_test_base_field_entity_base_field_info(EntityTypeInterface $entity_type) {
+  $fields = [];
+  if ($entity_type->id() === 'entity_test') {
+    $fields['links'] = BaseFieldDefinition::create('link')
+      ->setLabel(t('Links'))
+      ->setRevisionable(TRUE)
+      ->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED)
+      ->setDescription(t('Add links to the entity.'))
+      ->setRequired(FALSE)
+      ->setSettings([
+        'link_type' => LinkItemInterface::LINK_GENERIC,
+        'title' => DRUPAL_REQUIRED,
+      ])
+      ->setDisplayOptions('form', [
+        'type' => 'link_default',
+        'weight' => 49,
+      ]);
+  }
+  return $fields;
+}

core/modules/link/tests/modules/link_test_views/link_test_views.info.yml

@@ -0,0 +1,14 @@
+name: 'Link test views'
+type: module
+description: 'Provides default views for views link tests.'
+package: Testing
+# version: VERSION
+dependencies:
+  - drupal:node
+  - drupal:views
+  - drupal:link
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/link/tests/modules/link_test_views/test_views/views.view.test_link_tokens.yml

@@ -0,0 +1,205 @@
+langcode: en
+status: true
+dependencies:
+  config:
+    - field.storage.node.field_link
+  module:
+    - link
+    - node
+    - user
+id: test_link_tokens
+label: link
+module: views
+description: ''
+tag: ''
+base_table: node_field_data
+base_field: nid
+display:
+  default:
+    display_plugin: default
+    id: default
+    display_title: Default
+    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: full
+        options:
+          items_per_page: 10
+          offset: 0
+          id: 0
+          total_pages: null
+          expose:
+            items_per_page: false
+            items_per_page_label: 'Items per page'
+            items_per_page_options: '5, 10, 25, 50'
+            items_per_page_options_all: false
+            items_per_page_options_all_label: '- All -'
+            offset: false
+            offset_label: Offset
+          tags:
+            previous: '‹ previous'
+            next: 'next ›'
+            first: '« first'
+            last: 'last »'
+          quantity: 9
+      style:
+        type: default
+      row:
+        type: fields
+        options:
+          default_field_elements: true
+          inline: {  }
+          separator: ''
+          hide_empty: false
+      fields:
+        field_link:
+          id: field_link
+          table: node__field_link
+          field: field_link
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: true
+            text: "Formatted: {{ field_link }}<br />\nRaw uri: {{ field_link__uri }}<br />\nRaw title: {{ field_link__title }}<br />\nRaw options: {{ field_link__options }}."
+            make_link: false
+            path: '{{ field_link__uri }}'
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: false
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          click_sort_column: uri
+          type: link
+          settings:
+            trim_length: 80
+            url_only: false
+            url_plain: false
+            rel: '0'
+            target: '0'
+          group_column: ''
+          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
+          plugin_id: field
+      filters:
+        status:
+          value: '1'
+          table: node_field_data
+          field: status
+          plugin_id: boolean
+          entity_type: node
+          entity_field: status
+          id: status
+          expose:
+            operator: ''
+          group: 1
+      sorts:
+        created:
+          id: created
+          table: node_field_data
+          field: created
+          order: DESC
+          entity_type: node
+          entity_field: created
+          plugin_id: date
+          relationship: none
+          group_type: group
+          admin_label: ''
+          exposed: false
+          expose:
+            label: ''
+          granularity: second
+      title: link
+      header: {  }
+      footer: {  }
+      empty: {  }
+      relationships: {  }
+      arguments: {  }
+      display_extenders: {  }
+    cache_metadata:
+      contexts:
+        - 'languages:language_content'
+        - 'languages:language_interface'
+        - url.query_args
+        - 'user.node_grants:view'
+        - user.permissions
+      cacheable: false
+  page_1:
+    display_plugin: page
+    id: page_1
+    display_title: Page
+    position: 1
+    display_options:
+      display_extenders: {  }
+      path: test_link_tokens
+    cache_metadata:
+      contexts:
+        - 'languages:language_content'
+        - 'languages:language_interface'
+        - url.query_args
+        - 'user.node_grants:view'
+        - user.permissions
+      cacheable: false

core/modules/link/tests/src/Functional/GenericTest.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Functional;
+
+use Drupal\Tests\system\Functional\Module\GenericModuleTestBase;
+
+/**
+ * Generic module test for link.
+ *
+ * @group link
+ */
+class GenericTest extends GenericModuleTestBase {}

core/modules/link/tests/src/Functional/LinkFieldUITest.php

@@ -0,0 +1,259 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Functional;
+
+use Drupal\Core\Url;
+use Drupal\Component\Utility\Html;
+use Drupal\Core\Entity\Entity\EntityFormDisplay;
+use Drupal\link\LinkItemInterface;
+use Drupal\Tests\BrowserTestBase;
+use Drupal\Tests\field_ui\Traits\FieldUiTestTrait;
+
+/**
+ * Tests link field UI functionality.
+ *
+ * @group link
+ */
+class LinkFieldUITest extends BrowserTestBase {
+
+  use FieldUiTestTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = ['node', 'link', 'field_ui', 'block'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * A user that can edit content types.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $adminUser;
+
+  /**
+   * A user that should see the help texts.
+   *
+   * @var \Drupal\user\Entity\User
+   */
+  protected $helpTextUser;
+
+  /**
+   * The content type to add fields to.
+   *
+   * @var \Drupal\node\Entity\NodeType
+   */
+  protected $contentType;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->contentType = $this->drupalCreateContentType();
+    $this->adminUser = $this->drupalCreateUser([
+      'administer content types',
+      'administer node fields',
+      'administer node display',
+    ]);
+    $this->helpTextUser = $this->drupalCreateUser([
+      'create ' . $this->contentType->id() . ' content',
+    ]);
+    $this->drupalPlaceBlock('system_breadcrumb_block');
+  }
+
+  /**
+   * Tests the link field UI.
+   */
+  public function testFieldUI(): void {
+    foreach ($this->providerTestFieldUI() as $item) {
+      [$cardinality, $link_type, $title, $label, $field_name, $default_uri] = $item;
+      $this->runFieldUIItem($cardinality, $link_type, $title, $label, $field_name, $default_uri);
+    }
+  }
+
+  /**
+   * Provides test data for ::testFieldUI().
+   */
+  protected function providerTestFieldUI() {
+    // There are many combinations of field settings: where the description
+    // should show: variation on internal, external, both; cardinality (where
+    // the fieldset is hidden or used); and link text shown (required or
+    // optional) or disabled. There are two descriptions: field and URL help
+    // text.
+    $cardinalities = [1, 2];
+    $title_settings = [
+      DRUPAL_DISABLED,
+      DRUPAL_OPTIONAL,
+    ];
+    $link_types = [
+      LinkItemInterface::LINK_EXTERNAL => 'https://example.com',
+      LinkItemInterface::LINK_GENERIC => '',
+      LinkItemInterface::LINK_INTERNAL => '<front>',
+    ];
+
+    // Test all variations of link types on all cardinalities.
+    foreach ($cardinalities as $cardinality) {
+      foreach ($link_types as $link_type => $default_uri) {
+        // Now, test this with both the title enabled and disabled.
+        foreach ($title_settings as $title_setting) {
+          // Test both empty and non-empty labels.
+          foreach ([TRUE, FALSE] as $label_provided) {
+            // Generate a unique machine name for the field so it can be
+            // identified in the test.
+            $id = implode('_', [
+              'link',
+              $cardinality,
+              $link_type,
+              $title_setting,
+              (int) $label_provided,
+            ]);
+
+            // Use a unique label that contains some HTML.
+            $label = '<img src="https://example.com">' . $id;
+
+            yield [
+              $cardinality,
+              $link_type,
+              $title_setting,
+              $label_provided ? $label : '',
+              $id,
+              $default_uri,
+            ];
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Tests one link field UI item.
+   *
+   * @param int $cardinality
+   *   The field cardinality.
+   * @param int $link_type
+   *   Determine if the link is external, internal or both.
+   * @param int $title
+   *   Determine if the field will display the link text field.
+   * @param string $label
+   *   The field label.
+   * @param string $field_name
+   *   The unique machine name for the field.
+   * @param string $default_uri
+   *   The default URI value.
+   */
+  public function runFieldUIItem($cardinality, $link_type, $title, $label, $field_name, $default_uri) {
+    $this->drupalLogin($this->adminUser);
+    $type_path = 'admin/structure/types/manage/' . $this->contentType->id();
+
+    // Add a link field to the newly-created type.
+    $description = 'link field description';
+    $field_edit = [
+      'description' => $description,
+      'settings[link_type]' => (int) $link_type,
+    ];
+    if (!empty($default_uri)) {
+      $field_edit['set_default_value'] = '1';
+      $field_edit['default_value_input[field_' . $field_name . '][0][uri]'] = $default_uri;
+      $field_edit['default_value_input[field_' . $field_name . '][0][title]'] = 'Default title';
+    }
+    $storage_edit = [
+      'cardinality_number' => $cardinality,
+    ];
+    $this->fieldUIAddNewField($type_path, $field_name, $label, 'link', $storage_edit, $field_edit);
+
+    // Load the formatter page to check that the settings summary does not
+    // generate warnings.
+    // @todo Mess with the formatter settings a bit here.
+    $this->drupalGet("$type_path/display");
+    $this->assertSession()->pageTextContains('Link text trimmed to 80 characters');
+
+    // Make the fields visible in the form display.
+    $form_display_id = implode('.', ['node', $this->contentType->id(), 'default']);
+    $form_display = EntityFormDisplay::load($form_display_id);
+    $form_display->setComponent($field_name, ['region' => 'content']);
+    $form_display->save();
+
+    // Log in a user that is allowed to create this content type, see if
+    // the user can see the expected help text.
+    $this->drupalLogin($this->helpTextUser);
+
+    $add_path = 'node/add/' . $this->contentType->id();
+    $this->drupalGet($add_path);
+
+    $expected_help_texts = [
+      LinkItemInterface::LINK_EXTERNAL => 'This must be an external URL such as <em class="placeholder">https://example.com</em>.',
+      LinkItemInterface::LINK_GENERIC => 'You can also enter an internal path such as <em class="placeholder">/node/add</em> or an external URL such as <em class="placeholder">https://example.com</em>. Enter <em class="placeholder">&lt;front&gt;</em> to link to the front page. Enter <em class="placeholder">&lt;nolink&gt;</em> to display link text only',
+      LinkItemInterface::LINK_INTERNAL => rtrim(Url::fromRoute('<front>', [], ['absolute' => TRUE])->toString(), '/'),
+    ];
+
+    // Check that the help texts we assume should be there, is there.
+    $this->assertFieldContainsRawText($field_name, $expected_help_texts[$link_type]);
+    if ($link_type === LinkItemInterface::LINK_INTERNAL) {
+      // Internal links have no "system" description. Test that none
+      // of the other help texts show here.
+      $this->assertNoFieldContainsRawText($field_name, $expected_help_texts[LinkItemInterface::LINK_EXTERNAL]);
+      $this->assertNoFieldContainsRawText($field_name, $expected_help_texts[LinkItemInterface::LINK_GENERIC]);
+    }
+    // Also assert that the description we made is here, no matter what the
+    // cardinality or link setting.
+    if (!empty($label)) {
+      $this->assertFieldContainsRawText($field_name, $label);
+    }
+
+    // Test the default field value is used as expected.
+    $this->assertSession()->fieldValueEquals('field_' . $field_name . '[0][uri]', $default_uri);
+  }
+
+  /**
+   * Checks that given field contains the given raw text.
+   *
+   * @param string $field_name
+   *   The name of the field to check.
+   * @param string $text
+   *   The text to check.
+   *
+   * @internal
+   */
+  protected function assertFieldContainsRawText(string $field_name, string $text): void {
+    $this->assertTrue((bool) preg_match('/' . preg_quote($text, '/') . '/ui', $this->getFieldHtml($field_name)));
+  }
+
+  /**
+   * Checks that given field does not contain the given raw text.
+   *
+   * @param string $field_name
+   *   The name of the field to check.
+   * @param string $text
+   *   The text to check.
+   *
+   * @internal
+   */
+  protected function assertNoFieldContainsRawText(string $field_name, string $text): void {
+    $this->assertFalse((bool) preg_match('/' . preg_quote($text, '/') . '/ui', $this->getFieldHtml($field_name)));
+  }
+
+  /**
+   * Returns the raw HTML for the given field.
+   *
+   * @param $field_name
+   *   The name of the field for which to return the HTML.
+   *
+   * @return string
+   *   The raw HTML.
+   */
+  protected function getFieldHtml($field_name) {
+    $css_id = Html::cleanCssIdentifier('edit-field-' . $field_name . '-wrapper');
+    return $this->xpath('//*[@id=:id]', [':id' => $css_id])[0]->getHtml();
+  }
+
+}

core/modules/link/tests/src/Functional/Views/LinkViewsTokensTest.php

@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Functional\Views;
+
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\Tests\views\Functional\ViewTestBase;
+
+/**
+ * Tests the views integration for link tokens.
+ *
+ * @group link
+ */
+class LinkViewsTokensTest extends ViewTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = ['link_test_views'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_link_tokens'];
+
+  /**
+   * The field name used for the link field.
+   *
+   * @var string
+   */
+  protected $fieldName = 'field_link';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE, $modules = ['link_test_views']): void {
+    parent::setUp($import_test_views, $modules);
+
+    // Create Basic page node type.
+    $this->drupalCreateContentType([
+      'type' => 'page',
+      'name' => 'Basic page',
+    ]);
+
+    // Create a field.
+    FieldStorageConfig::create([
+      'field_name' => $this->fieldName,
+      'type' => 'link',
+      'entity_type' => 'node',
+      'cardinality' => 1,
+    ])->save();
+    FieldConfig::create([
+      'field_name' => $this->fieldName,
+      'entity_type' => 'node',
+      'bundle' => 'page',
+      'label' => 'link field',
+    ])->save();
+
+  }
+
+  public function testLinkViewsTokens(): void {
+    // Array of URI's to test.
+    $uris = [
+      'http://www.example.com' => 'example.com',
+    ];
+
+    // Add nodes with the URI's and titles.
+    foreach ($uris as $uri => $title) {
+      $values = ['type' => 'page'];
+      $values[$this->fieldName][] = ['uri' => $uri, 'title' => $title, 'options' => ['attributes' => ['class' => 'test-link-class']]];
+      $this->drupalCreateNode($values);
+    }
+
+    $this->drupalGet('test_link_tokens');
+
+    foreach ($uris as $uri => $title) {
+      // Formatted link: {{ field_link }}<br />
+      $this->assertSession()->responseContains("Formatted: <a href=\"$uri\" class=\"test-link-class\">$title</a>");
+
+      // Raw uri: {{ field_link__uri }}<br />
+      $this->assertSession()->responseContains("Raw uri: $uri");
+
+      // Raw title: {{ field_link__title }}<br />
+      $this->assertSession()->responseContains("Raw title: $title");
+
+      // Raw options: {{ field_link__options }}<br />
+      // Options is an array and should return empty after token replace.
+      $this->assertSession()->responseContains("Raw options: .");
+    }
+  }
+
+}

core/modules/link/tests/src/FunctionalJavascript/LinkFieldFormStatesTest.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\FunctionalJavascript;
+
+use Drupal\FunctionalJavascriptTests\WebDriverTestBase;
+
+/**
+ * Tests link field form states functionality.
+ *
+ * @group link
+ */
+class LinkFieldFormStatesTest extends WebDriverTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'entity_test',
+    'link',
+    'node',
+    'link_test_base_field',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->drupalLogin($this->drupalCreateUser([
+      'administer entity_test content',
+    ]));
+  }
+
+  /**
+   * @dataProvider linkFieldFormStatesData
+   */
+  public function testLinkFieldFormStates(string $uri, string $title): void {
+    $this->drupalGet('entity_test/add');
+    $session = $this->assertSession();
+    $session->elementNotExists('css', '#edit-links-0-uri[required]');
+    $session->elementNotExists('css', '#edit-links-0-title[required]');
+
+    $page = $this->getSession()->getPage();
+
+    if ($uri !== '') {
+      $page->fillField('links[0][uri]', $uri);
+      $session->elementNotExists('css', '#edit-links-0-uri[required]');
+      $session->elementExists('css', '#edit-links-0-title[required]');
+    }
+    else {
+      $page->fillField('links[0][title]', $title);
+      $session->elementExists('css', '#edit-links-0-uri[required]');
+      $session->elementNotExists('css', '#edit-links-0-title[required]');
+    }
+  }
+
+  /**
+   * Provides data for ::testLinkFieldJSFormStates.
+   */
+  public static function linkFieldFormStatesData() {
+    return [
+      'Fill uri, keep title empty' => [
+        'https://example.com',
+        '',
+      ],
+      'Fill title, keep uri empty' => [
+        '',
+        'https://example.com',
+      ],
+    ];
+  }
+
+}

core/modules/link/tests/src/Kernel/LinkItemSerializationTest.php

@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Kernel;
+
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\link\LinkItemInterface;
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\Component\Utility\UrlHelper;
+use Drupal\Tests\field\Kernel\FieldKernelTestBase;
+
+/**
+ * Tests link field serialization.
+ *
+ * @group link
+ */
+class LinkItemSerializationTest extends FieldKernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['link', 'serialization'];
+
+  /**
+   * The serializer service.
+   *
+   * @var \Symfony\Component\Serializer\SerializerInterface
+   */
+  protected $serializer;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->installEntitySchema('user');
+    $this->serializer = \Drupal::service('serializer');
+
+    // Create a generic, external, and internal link fields for validation.
+    FieldStorageConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test',
+      'type' => 'link',
+    ])->save();
+
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test',
+      'bundle' => 'entity_test',
+      'settings' => ['link_type' => LinkItemInterface::LINK_GENERIC],
+    ])->save();
+  }
+
+  /**
+   * Tests the serialization.
+   */
+  public function testLinkSerialization(): void {
+    // Create entity.
+    $entity = EntityTest::create();
+    $url = 'https://www.drupal.org?test_param=test_value';
+    $parsed_url = UrlHelper::parse($url);
+    $title = $this->randomMachineName();
+    $class = $this->randomMachineName();
+    $entity->field_test->uri = $parsed_url['path'];
+    $entity->field_test->title = $title;
+    $entity->field_test->first()
+      ->get('options')
+      ->set('query', $parsed_url['query']);
+    $entity->field_test->first()
+      ->get('options')
+      ->set('attributes', ['class' => $class]);
+    $entity->save();
+    $serialized = $this->serializer->serialize($entity, 'json');
+    $deserialized = $this->serializer->deserialize($serialized, EntityTest::class, 'json');
+    $options_expected = [
+      'query' => $parsed_url['query'],
+      'attributes' => ['class' => $class],
+    ];
+    $this->assertSame($options_expected, $deserialized->field_test->options);
+  }
+
+  /**
+   * Tests the deserialization.
+   */
+  public function testLinkDeserialization(): void {
+    // Create entity.
+    $entity = EntityTest::create();
+    $url = 'https://www.drupal.org?test_param=test_value';
+    $parsed_url = UrlHelper::parse($url);
+    $title = $this->randomMachineName();
+    $entity->field_test->uri = $parsed_url['path'];
+    $entity->field_test->title = $title;
+    $entity->field_test->first()
+      ->get('options')
+      ->set('query', $parsed_url['query']);
+    $json = json_decode($this->serializer->serialize($entity, 'json'), TRUE);
+    $json['field_test'][0]['options'] = 'string data';
+    $serialized = json_encode($json);
+    $this->expectException(\LogicException::class);
+    $this->expectExceptionMessage('The generic FieldItemNormalizer cannot denormalize string values for "options" properties of the "field_test" field (field item class: Drupal\link\Plugin\Field\FieldType\LinkItem).');
+    $this->serializer->deserialize($serialized, EntityTest::class, 'json');
+  }
+
+}

core/modules/link/tests/src/Kernel/LinkItemTest.php

@@ -0,0 +1,183 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Kernel;
+
+use Drupal\Component\Utility\UrlHelper;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\FieldItemInterface;
+use Drupal\Core\Url;
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\Tests\field\Kernel\FieldKernelTestBase;
+use Drupal\link\LinkItemInterface;
+
+/**
+ * Tests the new entity API for the link field type.
+ *
+ * @group link
+ */
+class LinkItemTest extends FieldKernelTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = ['link'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    // Create a generic, external, and internal link fields for validation.
+    FieldStorageConfig::create([
+      'field_name' => 'field_test',
+      'entity_type' => 'entity_test',
+      'type' => 'link',
+    ])->save();
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test',
+      'bundle' => 'entity_test',
+      'settings' => ['link_type' => LinkItemInterface::LINK_GENERIC],
+    ])->save();
+    FieldStorageConfig::create([
+      'field_name' => 'field_test_external',
+      'entity_type' => 'entity_test',
+      'type' => 'link',
+    ])->save();
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test_external',
+      'bundle' => 'entity_test',
+      'settings' => ['link_type' => LinkItemInterface::LINK_EXTERNAL],
+    ])->save();
+    FieldStorageConfig::create([
+      'field_name' => 'field_test_internal',
+      'entity_type' => 'entity_test',
+      'type' => 'link',
+    ])->save();
+    FieldConfig::create([
+      'entity_type' => 'entity_test',
+      'field_name' => 'field_test_internal',
+      'bundle' => 'entity_test',
+      'settings' => ['link_type' => LinkItemInterface::LINK_INTERNAL],
+    ])->save();
+  }
+
+  /**
+   * Tests using entity fields of the link field type.
+   */
+  public function testLinkItem(): void {
+    // Create entity.
+    $entity = EntityTest::create();
+    $url = 'https://www.drupal.org?test_param=test_value';
+    $parsed_url = UrlHelper::parse($url);
+    $title = $this->randomMachineName();
+    $class = $this->randomMachineName();
+    $entity->field_test->uri = $parsed_url['path'];
+    $entity->field_test->title = $title;
+    $entity->field_test->first()->get('options')->set('query', $parsed_url['query']);
+    $entity->field_test->first()->get('options')->set('attributes', ['class' => $class]);
+    $this->assertEquals([
+      'query' => $parsed_url['query'],
+      'attributes' => [
+        'class' => $class,
+      ],
+      'external' => TRUE,
+    ], $entity->field_test->first()->getUrl()->getOptions());
+    $entity->name->value = $this->randomMachineName();
+    $entity->save();
+
+    // Verify that the field value is changed.
+    $id = $entity->id();
+    $entity = EntityTest::load($id);
+    $this->assertInstanceOf(FieldItemListInterface::class, $entity->field_test);
+    $this->assertInstanceOf(FieldItemInterface::class, $entity->field_test[0]);
+    $this->assertEquals($parsed_url['path'], $entity->field_test->uri);
+    $this->assertEquals($parsed_url['path'], $entity->field_test[0]->uri);
+    $this->assertEquals($title, $entity->field_test->title);
+    $this->assertEquals($title, $entity->field_test[0]->title);
+    $this->assertEquals($title, $entity->field_test[0]->getTitle());
+    $this->assertEquals($class, $entity->field_test->options['attributes']['class']);
+    $this->assertEquals($parsed_url['query'], $entity->field_test->options['query']);
+
+    // Update only the entity name property to check if the link field data will
+    // remain intact.
+    $entity->name->value = $this->randomMachineName();
+    $entity->save();
+    $id = $entity->id();
+    $entity = EntityTest::load($id);
+    $this->assertEquals($parsed_url['path'], $entity->field_test->uri);
+    $this->assertEquals($class, $entity->field_test->options['attributes']['class']);
+    $this->assertEquals($parsed_url['query'], $entity->field_test->options['query']);
+
+    // Verify changing the field value.
+    $new_url = 'https://www.drupal.org';
+    $new_title = $this->randomMachineName();
+    $new_class = $this->randomMachineName();
+    $entity->field_test->uri = $new_url;
+    $entity->field_test->title = $new_title;
+    $entity->field_test->first()->get('options')->set('query', NULL);
+    $entity->field_test->first()->get('options')->set('attributes', ['class' => $new_class]);
+    $this->assertEquals($new_url, $entity->field_test->uri);
+    $this->assertEquals($new_title, $entity->field_test->title);
+    $this->assertEquals($new_class, $entity->field_test->options['attributes']['class']);
+    $this->assertNull($entity->field_test->options['query']);
+
+    // Read changed entity and assert changed values.
+    $entity->save();
+    $entity = EntityTest::load($id);
+    $this->assertEquals($new_url, $entity->field_test->uri);
+    $this->assertEquals($new_title, $entity->field_test->title);
+    $this->assertEquals($new_class, $entity->field_test->options['attributes']['class']);
+
+    // Check that if we only set uri the default values for title and options
+    // are also initialized.
+    $entity->field_test = ['uri' => 'internal:/node/add'];
+    $this->assertEquals('internal:/node/add', $entity->field_test->uri);
+    $this->assertNull($entity->field_test->title);
+    $this->assertSame([], $entity->field_test->options);
+
+    // Check that if we set uri and options then the default values are properly
+    // initialized.
+    $entity->field_test = [
+      'uri' => 'internal:/node/add',
+      'options' => ['query' => NULL],
+    ];
+    $this->assertEquals('internal:/node/add', $entity->field_test->uri);
+    $this->assertNull($entity->field_test->title);
+    $this->assertNull($entity->field_test->options['query']);
+
+    // Check that if we set the direct value of link field it correctly set the
+    // uri and the default values of the field.
+    $entity->field_test = 'internal:/node/add';
+    $this->assertEquals('internal:/node/add', $entity->field_test->uri);
+    $this->assertNull($entity->field_test->title);
+    $this->assertSame([], $entity->field_test->options);
+
+    // Check that setting options to NULL does not trigger an error when
+    // calling getUrl();
+    $entity->field_test->options = NULL;
+    $this->assertInstanceOf(Url::class, $entity->field_test[0]->getUrl());
+
+    // Check that setting LinkItem value NULL doesn't generate any error or
+    // warning.
+    $entity->field_test[0] = NULL;
+    $this->assertNull($entity->field_test[0]->getValue());
+
+    // Test the generateSampleValue() method for generic, external, and internal
+    // link types.
+    $entity = EntityTest::create();
+    $entity->field_test->generateSampleItems();
+    $entity->field_test_external->generateSampleItems();
+    $entity->field_test_internal->generateSampleItems();
+    $this->entityValidateAndSave($entity);
+  }
+
+}

core/modules/link/tests/src/Kernel/LinkItemUrlValidationTest.php

@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Kernel;
+
+use Drupal\Tests\field\Kernel\FieldKernelTestBase;
+
+/**
+ * Tests link field validation.
+ *
+ * @group link
+ */
+class LinkItemUrlValidationTest extends FieldKernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['link'];
+
+  /**
+   * Tests link validation.
+   */
+  public function testExternalLinkValidation(): void {
+    $definition = \Drupal::typedDataManager()
+      ->createDataDefinition('field_item:link');
+    $link_item = \Drupal::typedDataManager()->create($definition);
+    $test_links = $this->getTestLinks();
+
+    foreach ($test_links as $data) {
+      [$value, $expected_violations] = $data;
+      $link_item->setValue($value);
+      $violations = $link_item->validate();
+      $expected_count = count($expected_violations);
+      $this->assertCount($expected_count, $violations, sprintf('Violation message count error for %s', $value));
+      if ($expected_count) {
+        $i = 0;
+        foreach ($expected_violations as $error_msg) {
+          // If the expected message contains a '%' add the current link value.
+          if (strpos($error_msg, '%')) {
+            $error_msg = sprintf($error_msg, $value);
+          }
+          $this->assertEquals($error_msg, $violations[$i++]->getMessage());
+        }
+      }
+    }
+  }
+
+  /**
+   * Builds an array of links to test.
+   *
+   * @return array
+   *   The first element of the array is the link value to test. The second
+   *   value is an array of expected violation messages.
+   */
+  protected function getTestLinks() {
+    $violation_0 = "The path '%s' is invalid.";
+    $violation_1 = 'This value should be of the correct primitive type.';
+    return [
+      ['invalid://not-a-valid-protocol', [$violation_0]],
+      ['http://www.example.com/', []],
+      // Strings within parenthesis without leading space char.
+      ['http://www.example.com/strings_(string_within_parenthesis)', []],
+      // Numbers within parenthesis without leading space char.
+      ['http://www.example.com/numbers_(9999)', []],
+      ['http://www.example.com/?name=ferret&color=purple', []],
+      ['http://www.example.com/page?name=ferret&color=purple', []],
+      ['http://www.example.com?a=&b[]=c&d[]=e&d[]=f&h==', []],
+      ['http://www.example.com#colors', []],
+      // Use list of valid URLS from],
+      // https://cran.r-project.org/web/packages/rex/vignettes/url_parsing.html.
+      ["http://foo.com/blah_blah", []],
+      ["http://foo.com/blah_blah/", []],
+      ["http://foo.com/blah_blah_(wikipedia)", []],
+      ["http://foo.com/blah_blah_(wikipedia)_(again)", []],
+      ["http://www.example.com/wpstyle/?p=364", []],
+      ["https://www.example.com/foo/?bar=baz&inga=42&quux", []],
+      ["http://✪df.ws/123", []],
+      ["http://userid:password@example.com:8080", []],
+      ["http://userid:password@example.com:8080/", []],
+      ["http://userid@example.com", []],
+      ["http://userid@example.com/", []],
+      ["http://userid@example.com:8080", []],
+      ["http://userid@example.com:8080/", []],
+      ["http://userid:password@example.com", []],
+      ["http://userid:password@example.com/", []],
+      ["http://➡.ws/䨹", []],
+      ["http://⌘.ws", []],
+      ["http://⌘.ws/", []],
+      ["http://foo.com/blah_(wikipedia)#cite-1", []],
+      ["http://foo.com/blah_(wikipedia)_blah#cite-1", []],
+      // The following invalid URLs produce false positives.
+      ["http://foo.com/unicode_(✪)_in_parens", []],
+      ["http://foo.com/(something)?after=parens", []],
+      ["http://☺.damowmow.com/", []],
+      ["http://code.google.com/events/#&product=browser", []],
+      ["http://j.mp", []],
+      ["ftp://foo.bar/baz", []],
+      ["http://foo.bar/?q=Test%20URL-encoded%20stuff", []],
+      ["http://مثال.إختبار", []],
+      ["http://例子.测试", []],
+      ["http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", []],
+      ["http://1337.net", []],
+      ["http://a.b-c.de", []],
+      ["radar://1234", [$violation_0]],
+      ["h://test", [$violation_0]],
+      ["ftps://foo.bar/", [$violation_0]],
+      // Use invalid URLS from
+      // https://cran.r-project.org/web/packages/rex/vignettes/url_parsing.html.
+      ['http://', [$violation_0, $violation_1]],
+      ["http://?", [$violation_0, $violation_1]],
+      ["http://??", [$violation_0, $violation_1]],
+      ["http://??/", [$violation_0, $violation_1]],
+      ["http://#", [$violation_0, $violation_1]],
+      ["http://##", [$violation_0, $violation_1]],
+      ["http://##/", [$violation_0, $violation_1]],
+      ["//", [$violation_0, $violation_1]],
+      ["///a", [$violation_0, $violation_1]],
+      ["///", [$violation_0, $violation_1]],
+      ["http:///a", [$violation_0, $violation_1]],
+    ];
+  }
+
+}

core/modules/link/tests/src/Kernel/Plugin/migrate/field/d7/LinkFieldTest.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Kernel\Plugin\migrate\field\d7;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\link\Plugin\migrate\field\d7\LinkField;
+use Prophecy\Argument;
+
+/**
+ * @coversDefaultClass \Drupal\link\Plugin\migrate\field\d7\LinkField
+ * @group link
+ */
+class LinkFieldTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['system'];
+
+  /**
+   * @var \Drupal\migrate_drupal\Plugin\MigrateFieldInterface
+   */
+  protected $plugin;
+
+  /**
+   * @var \Drupal\migrate\Plugin\MigrationInterface
+   */
+  protected $migration;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->plugin = new LinkField([], 'link', []);
+
+    $migration = $this->prophesize(MigrationInterface::class);
+
+    // The plugin's alterFieldInstanceMigration() method will call
+    // mergeProcessOfProperty() and return nothing. So, in order to examine the
+    // process pipeline created by the plugin, we need to ensure that
+    // getProcess() always returns the last input to mergeProcessOfProperty().
+    $migration->mergeProcessOfProperty(Argument::type('string'), Argument::type('array'))
+      ->will(function ($arguments) use ($migration) {
+        $migration->getProcess()->willReturn($arguments[1]);
+      });
+
+    $this->migration = $migration->reveal();
+  }
+
+  /**
+   * @covers ::alterFieldInstanceMigration
+   */
+  public function testAlterFieldInstanceMigration($method = 'alterFieldInstanceMigration'): void {
+    $this->plugin->$method($this->migration);
+
+    $expected = [
+      'plugin' => 'static_map',
+      'source' => 'settings/title',
+      'bypass' => TRUE,
+      'map' => [
+        'disabled' => DRUPAL_DISABLED,
+        'optional' => DRUPAL_OPTIONAL,
+        'required' => DRUPAL_REQUIRED,
+      ],
+    ];
+    $this->assertSame($expected, $this->migration->getProcess());
+  }
+
+}

core/modules/link/tests/src/Unit/LinkFormatterTest.php

@@ -0,0 +1,155 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Unit;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldItemList;
+use Drupal\Core\Field\FieldTypePluginManagerInterface;
+use Drupal\Core\Path\PathValidatorInterface;
+use Drupal\Core\Routing\UrlGenerator;
+use Drupal\Core\Url;
+use Drupal\link\LinkItemInterface;
+use Drupal\link\Plugin\Field\FieldFormatter\LinkFormatter;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Tests the Field Formatter for the link field type.
+ *
+ * @group link
+ */
+class LinkFormatterTest extends UnitTestCase {
+
+  /**
+   * Tests when LinkItem::getUrl with malformed URL renders empty link.
+   *
+   * LinkItem::getUrl will throw \InvalidArgumentException.
+   */
+  public function testFormatterLinkItemUrlMalformed(): void {
+    $entity = $this->createMock(EntityInterface::class);
+
+    $linkItem = $this->createMock(LinkItemInterface::class);
+    $exception = new \InvalidArgumentException();
+    $linkItem->expects($this->any())
+      ->method('getParent')
+      ->willReturn($entity);
+    $linkItem->expects($this->once())
+      ->method('getUrl')
+      ->willThrowException($exception);
+    $linkItem->expects($this->any())
+      ->method('__get')
+      ->with('options')
+      ->willReturn([]);
+    $fieldDefinition = $this->createMock(FieldDefinitionInterface::class);
+    $fieldList = new FieldItemList($fieldDefinition, '', $linkItem);
+
+    $fieldTypePluginManager = $this->createMock(FieldTypePluginManagerInterface::class);
+    $fieldTypePluginManager->expects($this->once())
+      ->method('createFieldItem')
+      ->willReturn($linkItem);
+    $urlGenerator = $this->createMock(UrlGenerator::class);
+    $urlGenerator->expects($this->once())
+      ->method('generateFromRoute')
+      ->with('<none>', [], [], FALSE)
+      ->willReturn('http://example.com');
+    $container = new ContainerBuilder();
+    $container->set('plugin.manager.field.field_type', $fieldTypePluginManager);
+    $container->set('url_generator', $urlGenerator);
+    \Drupal::setContainer($container);
+    $fieldList->setValue([$linkItem]);
+
+    $pathValidator = $this->createMock(PathValidatorInterface::class);
+    $linkFormatter = new LinkFormatter('', [], $fieldDefinition, [], '', '', [], $pathValidator);
+    $elements = $linkFormatter->viewElements($fieldList, 'es');
+    $this->assertEquals('link', $elements[0]['#type']);
+  }
+
+  /**
+   * Tests when LinkItem::getUrl throws an unexpected exception.
+   */
+  public function testFormatterLinkItemUrlUnexpectedException(): void {
+    $exception = new \Exception('Unexpected!!!');
+
+    $linkItem = $this->createMock(LinkItemInterface::class);
+    $entity = $this->createMock(EntityInterface::class);
+    $linkItem->expects($this->any())
+      ->method('getParent')
+      ->willReturn($entity);
+    $linkItem->expects($this->once())
+      ->method('getUrl')
+      ->willThrowException($exception);
+    $linkItem->expects($this->any())
+      ->method('__get')
+      ->with('options')
+      ->willReturn([]);
+    $fieldDefinition = $this->createMock(FieldDefinitionInterface::class);
+    $fieldList = new FieldItemList($fieldDefinition, '', $linkItem);
+
+    $fieldTypePluginManager = $this->createMock(FieldTypePluginManagerInterface::class);
+    $fieldTypePluginManager->expects($this->once())
+      ->method('createFieldItem')
+      ->willReturn($linkItem);
+    $container = new ContainerBuilder();
+    $container->set('plugin.manager.field.field_type', $fieldTypePluginManager);
+    \Drupal::setContainer($container);
+    $fieldList->setValue([$linkItem]);
+
+    $pathValidator = $this->createMock(PathValidatorInterface::class);
+    $linkFormatter = new LinkFormatter('', [], $fieldDefinition, [], '', '', [], $pathValidator);
+    $this->expectException(\Exception::class);
+    $this->expectExceptionMessage('Unexpected!!!');
+    $linkFormatter->viewElements($fieldList, 'fr');
+  }
+
+  /**
+   * Tests when LinkItem::getUrl returns a functional URL.
+   */
+  public function testFormatterLinkItem(): void {
+    $expectedUrl = Url::fromUri('route:<front>');
+
+    $linkItem = $this->createMock(LinkItemInterface::class);
+    $entity = $this->createMock(EntityInterface::class);
+    $linkItem->expects($this->any())
+      ->method('getParent')
+      ->willReturn($entity);
+    $linkItem->expects($this->once())
+      ->method('getUrl')
+      ->willReturn($expectedUrl);
+    $linkItem->expects($this->any())
+      ->method('__get')
+      ->with('options')
+      ->willReturn([]);
+    $fieldDefinition = $this->createMock(FieldDefinitionInterface::class);
+    $fieldList = new FieldItemList($fieldDefinition, '', $linkItem);
+
+    $fieldTypePluginManager = $this->createMock(FieldTypePluginManagerInterface::class);
+    $fieldTypePluginManager->expects($this->once())
+      ->method('createFieldItem')
+      ->willReturn($linkItem);
+    $urlGenerator = $this->createMock(UrlGenerator::class);
+    $urlGenerator->expects($this->once())
+      ->method('generateFromRoute')
+      ->with('<front>', [], [], FALSE)
+      ->willReturn('http://example.com');
+    $container = new ContainerBuilder();
+    $container->set('plugin.manager.field.field_type', $fieldTypePluginManager);
+    $container->set('url_generator', $urlGenerator);
+    \Drupal::setContainer($container);
+    $fieldList->setValue([$linkItem]);
+
+    $pathValidator = $this->createMock(PathValidatorInterface::class);
+    $linkFormatter = new LinkFormatter('', [], $fieldDefinition, [], '', '', [], $pathValidator);
+    $elements = $linkFormatter->viewElements($fieldList, 'zh');
+    $this->assertEquals([
+      [
+        '#type' => 'link',
+        '#title' => 'http://example.com',
+        '#url' => $expectedUrl,
+      ],
+    ], $elements);
+  }
+
+}

core/modules/link/tests/src/Unit/Plugin/Validation/Constraint/LinkAccessConstraintValidatorTest.php

@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Unit\Plugin\Validation\Constraint;
+
+use Drupal\link\Plugin\Validation\Constraint\LinkAccessConstraint;
+use Drupal\link\Plugin\Validation\Constraint\LinkAccessConstraintValidator;
+use Drupal\Tests\UnitTestCase;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+/**
+ * Tests the LinkAccessConstraintValidator validator.
+ *
+ * @coversDefaultClass \Drupal\link\Plugin\Validation\Constraint\LinkAccessConstraintValidator
+ * @group validation
+ */
+class LinkAccessConstraintValidatorTest extends UnitTestCase {
+
+  /**
+   * Tests the access validation constraint for links.
+   *
+   * @covers ::validate
+   * @dataProvider providerValidate
+   */
+  public function testValidate(bool $mayLinkAnyPage, bool $urlAccess, bool $valid): void {
+    // Mock a Url object that returns a boolean indicating user access.
+    $url = $this->getMockBuilder('Drupal\Core\Url')
+      ->disableOriginalConstructor()
+      ->getMock();
+    if ($mayLinkAnyPage) {
+      $url->expects($this->never())
+        ->method('access');
+    }
+    else {
+      $url->expects($this->once())
+        ->method('access')
+        ->willReturn($urlAccess);
+    }
+
+    // Mock a link object that returns the URL object.
+    $link = $this->createMock('Drupal\link\LinkItemInterface');
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willReturn($url);
+
+    // Mock a user object that returns a boolean indicating user access to all
+    // links.
+    $user = $this->createMock('Drupal\Core\Session\AccountProxyInterface');
+    $user->expects($this->any())
+      ->method('hasPermission')
+      ->with($this->equalTo('link to any page'))
+      ->willReturn($mayLinkAnyPage);
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    if ($valid) {
+      $context->expects($this->never())
+        ->method('addViolation');
+    }
+    else {
+      $context->expects($this->once())
+        ->method('addViolation');
+    }
+
+    $constraint = new LinkAccessConstraint();
+    $validate = new LinkAccessConstraintValidator($user);
+    $validate->initialize($context);
+    $validate->validate($link, $constraint);
+  }
+
+  /**
+   * Data provider for LinkAccessConstraintValidator::validate().
+   *
+   * @return array
+   *   An array of tests, matching the parameter inputs for testValidate.
+   *
+   * @see \Drupal\Tests\link\LinkAccessConstraintValidatorTest::validate()
+   */
+  public static function providerValidate(): \Generator {
+    yield [TRUE, TRUE, TRUE];
+    yield [TRUE, FALSE, TRUE];
+    yield [FALSE, TRUE, TRUE];
+    yield [FALSE, FALSE, FALSE];
+  }
+
+}

core/modules/link/tests/src/Unit/Plugin/Validation/Constraint/LinkExternalProtocolsConstraintValidatorTest.php

@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Unit\Plugin\Validation\Constraint;
+
+use Drupal\Component\Utility\UrlHelper;
+use Drupal\Core\Url;
+use Drupal\link\Plugin\Validation\Constraint\LinkExternalProtocolsConstraint;
+use Drupal\link\Plugin\Validation\Constraint\LinkExternalProtocolsConstraintValidator;
+use Drupal\Tests\UnitTestCase;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+/**
+ * @coversDefaultClass \Drupal\link\Plugin\Validation\Constraint\LinkExternalProtocolsConstraintValidator
+ * @group Link
+ */
+class LinkExternalProtocolsConstraintValidatorTest extends UnitTestCase {
+
+  /**
+   * @covers ::validate
+   * @dataProvider providerValidate
+   * @runInSeparateProcess
+   */
+  public function testValidate($url, $valid): void {
+    $link = $this->createMock('Drupal\link\LinkItemInterface');
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willReturn(Url::fromUri($url));
+    $context = $this->createMock(ExecutionContextInterface::class);
+
+    if ($valid) {
+      $context->expects($this->never())
+        ->method('addViolation');
+    }
+    else {
+      $context->expects($this->once())
+        ->method('addViolation');
+    }
+
+    // Setup some more allowed protocols.
+    UrlHelper::setAllowedProtocols(['http', 'https', 'magnet']);
+
+    $constraint = new LinkExternalProtocolsConstraint();
+
+    $validator = new LinkExternalProtocolsConstraintValidator();
+    $validator->initialize($context);
+    $validator->validate($link, $constraint);
+  }
+
+  /**
+   * Data provider for ::testValidate.
+   */
+  public static function providerValidate() {
+    $data = [];
+
+    // Test allowed protocols.
+    $data[] = ['http://www.example.com', TRUE];
+    $data[] = ['https://www.example.com', TRUE];
+    // cSpell:disable-next-line
+    $data[] = ['magnet:?xt=urn:sha1:YNCKHTQCWBTRNJIV4WNAE52SJUQCZO5C', TRUE];
+
+    // Invalid protocols.
+    $data[] = ['ftp://ftp.funet.fi/pub/standards/RFC/rfc959.txt', FALSE];
+
+    return $data;
+  }
+
+  /**
+   * @covers ::validate
+   *
+   * @see \Drupal\Core\Url::fromUri
+   */
+  public function testValidateWithMalformedUri(): void {
+    $link = $this->createMock('Drupal\link\LinkItemInterface');
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willThrowException(new \InvalidArgumentException());
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    $context->expects($this->never())
+      ->method('addViolation');
+
+    $constraint = new LinkExternalProtocolsConstraint();
+
+    $validator = new LinkExternalProtocolsConstraintValidator();
+    $validator->initialize($context);
+    $validator->validate($link, $constraint);
+  }
+
+  /**
+   * @covers ::validate
+   */
+  public function testValidateIgnoresInternalUrls(): void {
+    $link = $this->createMock('Drupal\link\LinkItemInterface');
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willReturn(Url::fromRoute('example.test'));
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    $context->expects($this->never())
+      ->method('addViolation');
+
+    $constraint = new LinkExternalProtocolsConstraint();
+
+    $validator = new LinkExternalProtocolsConstraintValidator();
+    $validator->initialize($context);
+    $validator->validate($link, $constraint);
+  }
+
+}

core/modules/link/tests/src/Unit/Plugin/Validation/Constraint/LinkNotExistingInternalConstraintValidatorTest.php

@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Unit\Plugin\Validation\Constraint;
+
+use Drupal\Core\Routing\UrlGeneratorInterface;
+use Drupal\Core\Url;
+use Drupal\link\LinkItemInterface;
+use Drupal\link\Plugin\Validation\Constraint\LinkNotExistingInternalConstraint;
+use Drupal\link\Plugin\Validation\Constraint\LinkNotExistingInternalConstraintValidator;
+use Drupal\Tests\UnitTestCase;
+use PHPUnit\Framework\MockObject\MockObject;
+use Symfony\Component\Routing\Exception\RouteNotFoundException;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+/**
+ * @coversDefaultClass \Drupal\link\Plugin\Validation\Constraint\LinkNotExistingInternalConstraintValidator
+ * @group Link
+ */
+class LinkNotExistingInternalConstraintValidatorTest extends UnitTestCase {
+
+  /**
+   * @covers ::validate
+   */
+  public function testValidateFromUri(): void {
+    $url = Url::fromUri('https://www.drupal.org');
+
+    $link = $this->createMock(LinkItemInterface::class);
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willReturn($url);
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    $context->expects($this->never())
+      ->method('addViolation');
+
+    $this->validate($link, $context);
+  }
+
+  /**
+   * @covers ::validate
+   */
+  public function testValidateFromRoute(): void {
+    $url = Url::fromRoute('example.existing_route');
+
+    $urlGenerator = $this->createMock(UrlGeneratorInterface::class);
+    $urlGenerator->expects($this->any())
+      ->method('generateFromRoute')
+      ->with('example.existing_route', [], [])
+      ->willReturn('/example/existing');
+    $url->setUrlGenerator($urlGenerator);
+
+    $link = $this->createMock(LinkItemInterface::class);
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willReturn($url);
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    $context->expects($this->never())
+      ->method('addViolation');
+
+    $this->validate($link, $context);
+  }
+
+  /**
+   * @covers ::validate
+   */
+  public function testValidateFromNonExistingRoute(): void {
+    $url = Url::fromRoute('example.not_existing_route');
+
+    $urlGenerator = $this->createMock(UrlGeneratorInterface::class);
+    $urlGenerator->expects($this->any())
+      ->method('generateFromRoute')
+      ->with('example.not_existing_route', [], [])
+      ->willReturn(new RouteNotFoundException());
+    $url->setUrlGenerator($urlGenerator);
+
+    $link = $this->createMock(LinkItemInterface::class);
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willReturn($url);
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    $context->expects($this->never())
+      ->method('addViolation');
+
+    $this->validate($link, $context);
+  }
+
+  /**
+   * @covers ::validate
+   *
+   * @see \Drupal\Core\Url::fromUri
+   */
+  public function testValidateWithMalformedUri(): void {
+    $link = $this->createMock(LinkItemInterface::class);
+    $link->expects($this->any())
+      ->method('getUrl')
+      ->willThrowException(new \InvalidArgumentException());
+
+    $context = $this->createMock(ExecutionContextInterface::class);
+    $context->expects($this->never())
+      ->method('addViolation');
+
+    $this->validate($link, $context);
+  }
+
+  /**
+   * Validate the link.
+   */
+  protected function validate(LinkItemInterface&MockObject $link, ExecutionContextInterface&MockObject $context): void {
+    $validator = new LinkNotExistingInternalConstraintValidator();
+    $validator->initialize($context);
+    $validator->validate($link, new LinkNotExistingInternalConstraint());
+  }
+
+}

core/modules/link/tests/src/Unit/Plugin/migrate/field/d6/LinkFieldTest.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Unit\Plugin\migrate\field\d6;
+
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\Tests\UnitTestCase;
+use Drupal\link\Plugin\migrate\field\d6\LinkField;
+use Prophecy\Argument;
+
+/**
+ * @coversDefaultClass \Drupal\link\Plugin\migrate\field\d6\LinkField
+ * @group link
+ */
+class LinkFieldTest extends UnitTestCase {
+
+  /**
+   * @var \Drupal\migrate_drupal\Plugin\MigrateFieldInterface
+   */
+  protected $plugin;
+
+  /**
+   * @var \Drupal\migrate\Plugin\MigrationInterface
+   */
+  protected $migration;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->plugin = new LinkField([], 'link', []);
+
+    $migration = $this->prophesize(MigrationInterface::class);
+
+    // The plugin's defineValueProcessPipeline() method will call
+    // mergeProcessOfProperty() and return nothing. So, in order to examine the
+    // process pipeline created by the plugin, we need to ensure that
+    // getProcess() always returns the last input to mergeProcessOfProperty().
+    $migration->mergeProcessOfProperty(Argument::type('string'), Argument::type('array'))
+      ->will(function ($arguments) use ($migration) {
+        $migration->getProcess()->willReturn($arguments[1]);
+      });
+
+    $this->migration = $migration->reveal();
+  }
+
+  /**
+   * @covers ::defineValueProcessPipeline
+   */
+  public function testDefineValueProcessPipeline($method = 'defineValueProcessPipeline'): void {
+    $this->plugin->$method($this->migration, 'field_name', []);
+
+    $expected = [
+      'plugin' => 'field_link',
+      'source' => 'field_name',
+    ];
+    $this->assertSame($expected, $this->migration->getProcess());
+  }
+
+}

core/modules/link/tests/src/Unit/Plugin/migrate/process/FieldLinkTest.php

@@ -0,0 +1,133 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\link\Unit\Plugin\migrate\process;
+
+use Drupal\link\Plugin\migrate\process\FieldLink;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Row;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * @group Link
+ */
+class FieldLinkTest extends UnitTestCase {
+
+  /**
+   * Tests the URL transformations in the FieldLink process plugin.
+   *
+   * @dataProvider canonicalizeUriDataProvider
+   */
+  public function testCanonicalizeUri($url, $expected, $configuration = []): void {
+    $link_plugin = new FieldLink($configuration, '', [], $this->createMock(MigrationInterface::class));
+    $transformed = $link_plugin->transform([
+      'url' => $url,
+      'title' => '',
+      'attributes' => serialize([]),
+    ], $this->createMock(MigrateExecutableInterface::class), $this->getMockBuilder(Row::class)->disableOriginalConstructor()->getMock(), NULL);
+    $this->assertEquals($expected, $transformed['uri']);
+  }
+
+  /**
+   * Data provider for testCanonicalizeUri.
+   */
+  public static function canonicalizeUriDataProvider() {
+    return [
+      'Simple front-page' => [
+        '<front>',
+        'internal:/',
+      ],
+      'Front page with query' => [
+        '<front>?query=1',
+        'internal:/?query=1',
+      ],
+      'No leading forward slash' => [
+        'node/10',
+        'internal:/node/10',
+      ],
+      'Leading forward slash' => [
+        '/node/10',
+        'internal:/node/10',
+      ],
+      'Existing scheme' => [
+        'scheme:test',
+        'scheme:test',
+      ],
+      'Absolute URL with protocol prefix' => [
+        'http://www.google.com',
+        'http://www.google.com',
+      ],
+      'Absolute URL without protocol prefix' => [
+        'www.yahoo.com',
+        'http://www.yahoo.com',
+      ],
+      'Absolute URL without protocol prefix nor www' => [
+        'yahoo.com',
+        'https://yahoo.com',
+        ['uri_scheme' => 'https://'],
+      ],
+      'Absolute URL without explicit protocol (protocol-relative)' => [
+        '//example.com',
+        'http://example.com',
+      ],
+      'Absolute URL with non-standard characters' => [
+        'http://www.ßÀÑÐ¥ƒå¢ë.com',
+        'http://www.ßÀÑÐ¥ƒå¢ë.com',
+      ],
+      'Absolute URL with non-standard characters, without protocol prefix' => [
+        'www.ÐØÑ¢åþë.com',
+        'http://www.ÐØÑ¢åþë.com',
+      ],
+      'Absolute URL with non-standard top level domain' => [
+        'http://www.example.xxx',
+        'http://www.example.xxx',
+      ],
+      'Internal link with fragment' => [
+        '/node/10#top',
+        'internal:/node/10#top',
+      ],
+      'External link with fragment' => [
+        'http://www.example.com/page#links',
+        'http://www.example.com/page#links',
+      ],
+      'empty' => [
+        '',
+        'route:<nolink>',
+      ],
+      'No link' => [
+        '<nolink>',
+        'route:<nolink>',
+      ],
+      'none' => [
+        '<none>',
+        'route:<nolink>',
+      ],
+    ];
+  }
+
+  /**
+   * Tests the attributes that are deeply serialized are discarded.
+   */
+  public function testCanonicalizeUriSerialized(): void {
+    $link_plugin = new FieldLink([], '', [], $this->createMock(MigrationInterface::class));
+    $migrate_executable = $this->createMock(MigrateExecutableInterface::class);
+    $row = new Row();
+
+    $transformed = $link_plugin->transform([
+      'url' => '',
+      'title' => '',
+      'attributes' => serialize(serialize(['not too deep'])),
+    ], $migrate_executable, $row, NULL);
+    $this->assertEquals(['not too deep'], $transformed['options']['attributes']);
+
+    $transformed = $link_plugin->transform([
+      'url' => '',
+      'title' => '',
+      'attributes' => serialize(serialize(serialize(['too deep']))),
+    ], $migrate_executable, $row, NULL);
+    $this->assertEmpty($transformed['options']['attributes']);
+  }
+
+}

core/modules/link/tests/themes/link_test_theme/link_test_theme.info.yml

@@ -0,0 +1,10 @@
+name: 'Link Test Theme'
+type: theme
+description: 'Theme for testing link module'
+# version: VERSION
+base theme: stark
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/link/tests/themes/link_test_theme/templates/link-formatter-link-separate.html.twig

@@ -0,0 +1,22 @@
+{#
+/**
+ * @file
+ * Theme override of a link with separate title and URL elements.
+ *
+ * Available variables:
+ * - link: The link that has already been formatted by l().
+ * - title: (optional) A descriptive or alternate title for the link, which may
+ *   be different than the actual link text.
+ *
+ * @see template_preprocess()
+ * @see template_preprocess_link_formatter_link_separate()
+ */
+#}
+{% apply spaceless %}
+  <div class="link-item">
+    {% if title %}
+      <div class="link-title">{{ title }}</div>
+    {% endif %}
+    <div class="link-url">{{ link }}</div>
+  </div>
+{% endapply %}