static void verifyThreadWasNotInterrupted() {
    assertFalse(Thread.currentThread().isInterrupted());
  }

  static void clearInterrupt() {
    Thread.interrupted();
  }

  /**
   * Retrieves the result of a {@code Future} known to be done but uses the {@code get(long,
   * TimeUnit)} overload in order to test that method.
   */
  static <V> V getDoneFromTimeoutOverload(Future<V> future) throws ExecutionException {

            builderLambda.accept(builder);
            final UpdateResponse response = builder.execute().actionGet(fessConfig.getIndexIndexTimeout());
            return response.getResult() == Result.CREATED || response.getResult() == Result.UPDATED;
        } catch (final OpenSearchException e) {
            throw new SearchEngineClientException("Failed to update doc  " + id, e);
        }
    }

	// is too large we are basically just thrashing the CPU D-cache.
	// So if the result length is larger than an empirically-found
	// limit (8KB), we stop growing the source string once the limit
	// is reached and keep reusing the same source string - that
	// should therefore be always resident in the L1 cache - until we
	// have completed the construction of the result.
	// This yields significant speedups (up to +100%) in cases where

   *
   * @since 11.0
   */
  @Override
  public ImmutableListMultimap<V, K> inverse() {
    ImmutableListMultimap<V, K> result = inverse;
    return (result == null) ? (inverse = invert()) : result;
  }

  private ImmutableListMultimap<V, K> invert() {
    Builder<V, K> builder = builder();
    for (Entry<K, V> entry : entries()) {

import org.apache.maven.api.DownloadedArtifact;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.annotations.Nullable;

/**
 * The Artifact Result
 *
 * @since 4.0.0
 */
@Experimental
public interface ArtifactResolverResult {
    /**
     * @return {@link Artifact}
     */
    @Nonnull
    Collection<DownloadedArtifact> getArtifacts();

<p>
A function type denotes the set of all functions with the same parameter
and result types. The value of an uninitialized variable of function type
is <code>nil</code>.
</p>

<pre class="ebnf">
FunctionType   = "func" Signature .
Signature      = Parameters [ Result ] .
Result         = Parameters | Type .
Parameters     = "(" [ ParameterList [ "," ] ] ")" .

        ResolutionGroup result =
                new ResolutionGroup(pomArtifact, relocatedArtifact, artifacts, managedVersions, aggregatedRepositories);

        cache.put(
                artifact,
                request.isResolveManagedVersions(),
                request.getLocalRepository(),
                request.getRemoteRepositories(),
                result);

        return result;
    }

                send the client an error.

                If `auto_error` is set to `False`, when the HTTP Authorization header
                is not available, instead of erroring out, the dependency result will
                be `None`.

                This is useful when you want to have optional authentication.

                It is also useful when you want to have authentication that can be

}

// Parse parses s as an S3 ETag, returning the result.
// The string can be an encrypted, singlepart
// or multipart S3 ETag. It returns an error if s is
// not a valid textual representation of an ETag.
func Parse(s string) (ETag, error) {
	const strict = false
	return parse(s, strict)
}

// parse parse s as an S3 ETag, returning the result.
// It operates in one of two modes:
//   - strict

 * which collects necessary information for build scan.
 */
fun <T : AbstractBuildScanInfoCollectingService> Project.registerBuildScanInfoCollectingService(
    /* the implementation class to collect information from task execution result */
    klass: Class<T>,
    /* which tasks we need to monitor? For example, cache-miss-monitor monitors `AbstractCompile` tasks */
    taskFilter: (Task) -> Boolean,