pos++ // Consume '"' open quote.
          val parameterStart = pos
          pos = value.indexOf('"', pos)
          parameter = value.substring(parameterStart, pos)
          pos++ // Consume '"' close quote (if necessary).
        } else {
          // Unquoted string.
          val parameterStart = pos
          pos = value.indexOfElement(",;", pos)
          parameter = value.substring(parameterStart, pos).trim()

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;

import org.apache.maven.artifact.versioning.VersionRange;

/**
 * ArtifactUtils
 */
public final class ArtifactUtils {

    public static boolean isSnapshot(String version) {
        if (version != null) {
            if (version.regionMatches(
                    true,

    response.body.string()
    val cached = cacheGet(cache, request)
    if (shouldWriteToCache) {
      assertThat(cached).isNotNull()
      cached!!.body.close()
    } else {
      assertThat(cached).isNull()
    }
    server.close() // tearDown() isn't sufficient; this test starts multiple servers
  }

  private fun assertSubsequentResponseCached(
    initialResponseCode: Int,

Porém nós queremos poder parametrizar o conteúdo fixo.

## Uma instância "chamável" { #a-callable-instance }

Em Python existe uma maneira de fazer com que uma instância de uma classe seja um "chamável".

Não propriamente a classe (que já é um chamável), mas a instância desta classe.

Para fazer isso, nós declaramos o método `__call__`:

{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[12] *}

import java.util.concurrent.atomic.AtomicLong;
import org.jspecify.annotations.NullUnmarked;

/**
 * Single-threaded benchmark for {@link LoadingCache}.
 *
 * @author Charles Fry
 */
@NullUnmarked
public class LoadingCacheSingleThreadBenchmark {
  @Param({"1000", "2000"})
  int maximumSize;

  @Param("5000")
  int distinctKeys;

  @Param("4")
  int segments;

     */
    void reportPluginMojoValidationIssue(
            IssueLocality locality,
            MavenSession mavenSession,
            MojoDescriptor mojoDescriptor,
            Class<?> mojoClass,
            String issue);

@Tag("Slow")
class InterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var client = clientTestRule.newClient()
  private val callback = RecordingCallback()

  @Test
  fun applicationInterceptorsCanShortCircuitResponses() {
    server.close() // Accept no connections.
    val request =

   * described in the class documentation.
   *
   * @throws NullPointerException if any of {@code elements} is null
   * @since 6.0
   */
  public static <E> ImmutableMultiset<E> copyOf(E[] elements) {
    return copyFromElements(elements);
  }

  /**
   * Returns an immutable multiset containing the given elements, in the "grouped iteration order"
   * described in the class documentation.
   *

	_, err := target.isActive()
	if err != nil {
		return err
	}

	return target.send(eventData)
}

// Close - does nothing and available for interface compatibility.
func (target *MQTTTarget) Close() error {
	if target.client != nil {
		target.client.Disconnect(100)
	}
	close(target.quitCh)
	return nil
}

func (target *MQTTTarget) init() error {
	return target.initOnce.Do(target.initMQTT)
}

import org.codelibs.fess.suggest.Suggester;
import org.codelibs.opensearch.runner.OpenSearchRunner;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class AnalyzerNormalizerTest {
    static Suggester suggester;
    static OpenSearchRunner runner;

    @BeforeClass
    public static void beforeClass() throws Exception {
        runner = new OpenSearchRunner();