private lateinit var client: OkHttpClient
  private lateinit var cache: Cache
  private val nullHostnameVerifier = HostnameVerifier { _: String?, _: SSLSession? -> true }
  private val cookieManager = CookieManager()
  private lateinit var server: MockWebServer

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server

    platform.assumeNotOpenJSSE()

    return super.asMap();
  }

  /**
   * Stores a key-value pair in the multimap.
   *
   * @param key key to store in the multimap
   * @param value value to store in the multimap
   * @return {@code true} if the method increased the size of the multimap, or {@code false} if the
   *     multimap already contained the key-value pair
   */
  @CanIgnoreReturnValue
  @Override

// license that can be found in the LICENSE file.

// This input was created by taking the instruction productions in
// the old assembler's (6a's) grammar and hand-writing complete
// instructions for each rule, to guarantee we cover the same space.

#include "../../../../../runtime/textflag.h"

TEXT	foo(SB), DUPOK|NOSPLIT, $0

// LTYPE1 nonrem	{ outcode($1, &$2); }
	NEGQ	R11
	NEGQ	4(R11)
	NEGQ	foo+4(SB)

            return null;
        });
        kuromojiService.store(body.dictId, entity);
        return asJson(
                new ApiResult.ApiUpdateResponse().id(String.valueOf(entity.getId())).created(true).status(ApiResult.Status.OK).result());
    }

    // POST /api/admin/dict/kuromoji/setting/{dictId}
    @Execute
    public JsonResponse<ApiResult> post$setting(final String dictId, final EditBody body) {

    return stream!!.source
  }

  override fun trailers(): Headers {
    return stream!!.trailers()
  }

  override fun cancel() {
    canceled = true
    stream?.closeLater(ErrorCode.CANCEL)
  }

  companion object {
    private const val CONNECTION = "connection"
    private const val HOST = "host"
    private const val KEEP_ALIVE = "keep-alive"

    ImmutableMap<Object, Integer> hashExpectations;

    void expectEquivalent(Object a, Object b) {
      checkRecording();
      equivalentExpectationsBuilder.put(a, b, true);
    }

    void expectDistinct(Object a, Object b) {
      checkRecording();
      equivalentExpectationsBuilder.put(a, b, false);
    }

    void expectHash(Object object, int hash) {

    return size() == 0;
  }

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    for (Collection<V> collection : asMap().values()) {
      if (collection.contains(value)) {
        return true;
      }
    }

    return false;
  }

  @Override
  public boolean containsEntry(@CheckForNull Object key, @CheckForNull Object value) {
    Collection<V> collection = asMap().get(key);

    ImmutableMap<Object, Integer> hashExpectations;

    void expectEquivalent(Object a, Object b) {
      checkRecording();
      equivalentExpectationsBuilder.put(a, b, true);
    }

    void expectDistinct(Object a, Object b) {
      checkRecording();
      equivalentExpectationsBuilder.put(a, b, false);
    }

    void expectHash(Object object, int hash) {

            String type,
            ArtifactScopeEnum artifactScope,
            String classifier,
            String artifactUri) {
        this(groupId, name, version, type, artifactScope, classifier, artifactUri, null, true, null);
    }

    @SuppressWarnings("checkstyle:parameternumber")
    public ArtifactMetadata(
            String groupId,
            String name,
            String version,
            String type,

            } else {
                config = new ConsolePrompt.UiConfig("❯", "◯ ", "◉ ", "◯ ");
            }
            config.setCancellableFirstPrompt(true);

            context.reader =
                    LineReaderBuilder.builder().terminal(context.terminal).build();
            context.prompt = new ConsolePrompt(context.reader, context.terminal, config);