}

  /**
   * Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
   * elements.
   *
   * @param distinctElements the expected number of distinct elements
   * @throws IllegalArgumentException if {@code distinctElements} is negative
   */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create(int distinctElements) {
    return new LinkedHashMultiset<>(distinctElements);
  }

        this.location = (location != null) ? location : "(memory)";
        this.hashCode = this.content.hashCode();
    }

    @Override
    public InputStream getInputStream() throws IOException {
        return new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));
    }

    @Override
    public String getLocation() {
        return location;
    }

    /**

    Key createKey(
            Plugin plugin,
            DependencyFilter extensionFilter,
            List<RemoteRepository> repositories,
            RepositorySystemSession session);

    CacheRecord get(Key key) throws PluginResolutionException;

    CacheRecord put(Key key, List<Artifact> pluginArtifacts);

    CacheRecord put(Key key, PluginResolutionException e);

    void flush();

    /**

   * {@code firstEntry}, you may wish to override {@code firstKey} to forward to this
   * implementation.
   */
  protected K standardFirstKey() {
    Entry<K, V> entry = firstEntry();
    if (entry == null) {
      throw new NoSuchElementException();
    } else {
      return entry.getKey();
    }
  }

  @Override
  public @Nullable Entry<K, V> lastEntry() {
    return delegate().lastEntry();
  }

  /**

   * {@code firstEntry}, you may wish to override {@code firstKey} to forward to this
   * implementation.
   */
  protected K standardFirstKey() {
    Entry<K, V> entry = firstEntry();
    if (entry == null) {
      throw new NoSuchElementException();
    } else {
      return entry.getKey();
    }
  }

  @Override
  public @Nullable Entry<K, V> lastEntry() {
    return delegate().lastEntry();
  }

  /**

      this.windowSizeIncrement = windowSizeIncrement
    }

    override fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,
      exclusive: Boolean,
    ): Unit = throw UnsupportedOperationException()

    override fun pushPromise(
      streamId: Int,
      associatedStreamId: Int,
      headerBlock: List<Header>,
    ) {
      this.type = Http2.TYPE_PUSH_PROMISE

        if (!iterator.hasNext()) {
          iterator = iterable.iterator();
        }
        return iterator.next();
      }

      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }

  static <T extends @Nullable Object> T get(Iterator<T> iterator, int position) {
    for (int i = 0; i < position; i++) {
      iterator.next();

        } catch (InvalidVersionSpecificationException e) {
            throw new RuntimeException(e);
        }
    }

    private VersionRange parseVersionRange(String spec) {
        try {
            return versionScheme.parseVersionRange(spec);
        } catch (InvalidVersionSpecificationException e) {
            throw new RuntimeException(e);
        }
    }

        model: CIBuildModel,
        stage: Stage,
        performanceTestCoverage: PerformanceTestCoverage,
        bucketIndex: Int,
    ): PerformanceTest

    fun getName(testCoverage: TestCoverage): String = throw UnsupportedOperationException()
}

data class TestProjectDuration(
    val testProject: String,
    val scenarioDurations: List<PerformanceTestDuration>,
) {

            if (values.length > 2) {
                throw new InvalidQueryException(messages -> messages.addErrorsInvalidQuerySortValue(UserMessages.GLOBAL_PROPERTY_KEY, text),
                        "Invalid sort field: " + termQuery);
            }
            final String sortField = values[0];
            if (!getQueryFieldConfig().isSortField(sortField)) {
                throw new InvalidQueryException(