return publicSuffixIndex() != NO_SUFFIX_FOUND;
  }

  /**
   * Returns the {@linkplain #isPublicSuffix() public suffix} portion of the domain name, or {@code
   * null} if no public suffix is present.
   *
   * @since 6.0
   */
  public @Nullable InternetDomainName publicSuffix() {
    return hasPublicSuffix() ? ancestor(publicSuffixIndex()) : null;
  }

  /**

   * formally, removes an element {@code e} such that {@code o.equals(e)}, if this queue contains
   * one or more such elements. Returns {@code true} if this queue contained the specified element
   * (or equivalently, if this queue changed as a result of the call).
   *
   * @param o element to be removed from this queue, if present

   * from the map.
   *
   * The get method returns a WrappedCollection, which decorates the collection
   * in the map (if the key is present) or an empty collection (if the key is
   * not present). When the collection delegate in the WrappedCollection is
   * empty, the multimap may contain subsequently added values for that key. To

   *
   * <p>All methods are no-ops by default, implementors should override the ones they care about.
   *
   * @author Luke Sandberg
   * @since 15.0 (present as an interface in 13.0)
   */
  abstract class Listener {
    /** Constructor for use by subclasses. */
    public Listener() {}

    /**

   * the {@link ByteSource} returned by {@link #asByteSource} is garbage collected. Prefer to {@link
   * #reset} the stream explicitly, rather than rely on garbage collection: If you call {@link
   * #reset} explicitly, you can call it more promptly, and you can appropriately handle any
   * exception that results.
   *

			}
			return nil, fmt.Errorf("%w: %s.%s", ErrUnsupportedDataType, modelType.PkgPath(), modelType.Name())
		}
	}

	// Cache the Schema for performance,
	// Use the modelType or modelType + schemaTable (if it present) as cache key.
	var schemaCacheKey interface{} = modelType
	if specialTableName != "" {
		schemaCacheKey = fmt.Sprintf("%p-%s", modelType, specialTableName)
	}

	// Load exist schema cache, return if exists

        versions.add(v);
        return versions;
    }

    /**
     * Group a set of files by the version in which they first appeared, up until the supplied version. Any files not
     * present in an earlier version are assumed to have been introduced in the specified version.
     *
     * <p>This method works by finding all git tags prior to {@param versionString} in the same minor series, and

   */
  @CanIgnoreReturnValue
  int remove(@CompatibleWith("E") @Nullable Object element, int occurrences);

  /**
   * Removes a <i>single</i> occurrence of the specified element from this multiset, if present.
   *
   * <p>This method refines {@link Collection#remove} to further specify that it <b>may not</b>
   * throw an exception in response to {@code element} being null or of the wrong type.
   *

        } catch (Exception e) {
            // It's ok if it fails, we just want to verify reset was called
        }

        // Request/response reset should happen on retry
        verify(req, atLeastOnce()).reset();
        verify(resp, atLeastOnce()).reset();
        // Verify disconnect was called on retry
        verify(c, atLeastOnce()).disconnect(eq(true));
    }

    @Test

        // This modifies the element in place and marks it as modified
        root.attribute("xmlns", targetNamespace);
        context.detail("Updated namespace to " + targetNamespace);

        // Update schema location if present
        String currentSchemaLocation = root.attribute("xsi:schemaLocation");
        if (currentSchemaLocation != null) {
            String newSchemaLocation = getSchemaLocationForModelVersion(targetModelVersion);