* host specifier is a domain name, the string will be normalized to all lower case. If the
   * specifier was an IPv6 address without brackets, brackets are added so that the result will be
   * usable in the host part of a URI.
   */
  @Override
  public String toString() {
    return canonicalForm;
  }

    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertSize(3);
  }

  public void testEquals() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    // We know that we have only added non-null Characters.
    Table<String, Integer, Character> hashCopy =
        HashBasedTable.create((Table<String, Integer, ? extends Character>) table);

    this.itemReporter = checkNotNull(itemReporter);
  }

  /**
   * Adds {@code equalityGroup} with objects that are supposed to be equal to each other and not
   * equal to any other equality groups added to this tester.
   *
   * <p>The {@code @Nullable} annotations on the {@code equalityGroup} parameter imply that the
   * objects, and the array itself, can be null. That is for programmer convenience, when the

	}{
		{
			name:     "equal",
			features: []string{"A", "B", "C"},
			required: []string{"A", "B", "C"},
			ok:       true,
			out:      "",
		},
		{
			name:     "feature added",
			features: []string{"A", "B", "C", "D", "E", "F"},
			required: []string{"B", "D"},
			ok:       false,
			out:      "+A\n+C\n+E\n+F\n",
		},
		{
			name:     "feature removed",

                        hasUpgrades |= addPluginManagementForEffectivePlugins(context, pomDocument, pluginsForThisPom);
                        context.detail("Added plugin management to " + pomPath + " (target parent for "
                                + pluginsForThisPom.size() + " plugins)");
                    }

                    if (hasUpgrades) {

 * package, whether it is a subtype of {@code ImmutableCollection} or not.
 *
 * <h4>Guarantees</h4>
 *
 * <p>Each makes the following guarantees:
 *
 * <ul>
 *   <li><b>Shallow immutability.</b> Elements can never be added, removed or replaced in this
 *       collection. This is a stronger guarantee than that of {@link
 *       Collections#unmodifiableCollection}, whose contents change whenever the wrapped collection
 *       is modified.

        .build()
    val certB =
      HeldCertificate
        .Builder()
        .serialNumber(3L)
        .signedBy(certA)
        .build()
    val cleaner = get(root.certificate)
    // Root is added!
    assertThat(cleaner.clean(list(certB, certA), "hostname")).isEqualTo(
      list(certB, certA, root),
    )
  }

  @Test
  fun unorderedChainOfCertificatesWithRoot() {
    val root =

 *
 * <p>When iterating through the collections supplied by this class, the ordering of values for a
 * given key agrees with the order in which the values were added.
 *
 * <p>This multimap allows duplicate key-value pairs. After adding a new key-value pair equal to an
 * existing key-value pair, the {@code ArrayListMultimap} will contain entries for both the new
 * value and the old value.

     ii) additions to the Program;
  where such changes and/or additions to the Program originate from
  and are Distributed by that particular Contributor. A Contribution
  "originates" from a Contributor if it was added to the Program by
  such Contributor itself or anyone acting on such Contributor's behalf.
  Contributions do not include changes or additions to the Program that
  are not Modified Works.

            assertTrue(result.contains("            <plugin>"), "Plugin element should be properly indented");
        }

        @Test
        @DisplayName("should format pluginManagement with proper indentation when added")
        void shouldFormatPluginManagementWithProperIndentationWhenAdded() throws Exception {
            // Use a POM that will trigger pluginManagement addition by having a plugin without version
            String pomXml = """