switch ( type ) {
        case EncryptionNegotiateContext.NEGO_CTX_ENC_TYPE:
            return new EncryptionNegotiateContext();
        case PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE:
            return new PreauthIntegrityNegotiateContext();
        }
        return null;
    }


    /**
     * {@inheritDoc}
     *

                    }
                    if ( updateSnapshotVersions )
                    {
                        java.util.Map<String, SnapshotVersion> versions = new java.util.LinkedHashMap<>();
                        // never convert from legacy to new format if either source or target is legacy format
                        if ( !v.getSnapshotVersions().isEmpty() )
                        {

        FileUtil.writeBytes(propFile.getAbsolutePath(), "".getBytes());
        ComponentUtil.register(new DynamicProperties(propFile), "systemProperties");
        crawlingConfigHelper = new CrawlingConfigHelper();
        crawlingConfigHelper.init();
        ComponentUtil.register(crawlingConfigHelper, "crawlingConfigHelper");
        ComponentUtil.register(new WebConfigService() {
            @Override

            return id;
        }
    }

    @Test
    void testHashCodeEquals() {
        MavenArtifactRepositorySubclass r1 = new MavenArtifactRepositorySubclass("foo");
        MavenArtifactRepositorySubclass r2 = new MavenArtifactRepositorySubclass("foo");
        MavenArtifactRepositorySubclass r3 = new MavenArtifactRepositorySubclass("bar");

        assertTrue(r1.hashCode() == r2.hashCode());

    @Override
    public void setUp() throws Exception {
        super.setUp();
        languageHelper = new LanguageHelper();
        languageHelper.langFields = new String[] { "title", "content" };
    }

    public void test_createScript() {
        Map<String, Object> doc = new HashMap<>();
        assertEquals("aaa", languageHelper.createScript(doc, "aaa").getIdOrCode());

        doc.put("lang", "ja");

        private Server server;

        public TestApiExtractorServer(final int port) {
            server = new Server(port);

            final RequestHandlerImpl request_handler = new RequestHandlerImpl();
            final HandlerList handlers = new HandlerList();
            handlers.setHandlers(new Handler[] { request_handler, new DefaultHandler() });
            server.setHandler(handlers);
        }

        public void start() {

    assertEquals(expected, new String(buf));
    assertFullyRead(reader);

    // read in chunks to fixed array
    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {
      builder.append(buf, 0, read);
    }
    assertEquals(expected, builder.toString());

    final Runnable[] manualExecutorTask = new Runnable[1];
    Executor manualExecutor =
        new Executor() {
          @Override
          public void execute(Runnable task) {
            manualExecutorTask[0] = task;
          }
        };

    results.add(serializer.submit(Callables.returning(null), manualExecutor));
    final Future<?>[] thingToCancel = new Future<?>[1];

    @Nullable String string;
  }

  public void testBuilder_withMutableEntry() {
    ImmutableMap.Builder<String, Integer> builder = new Builder<>();
    final StringHolder holder = new StringHolder();
    holder.string = "one";
    Entry<String, Integer> entry =
        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

    MockCallback callback = new MockCallback(e);
    addCallback(f, callback, directExecutor());
  }

  public void testOnSuccessThrowsRuntimeException() throws Exception {
    RuntimeException exception = new RuntimeException();
    String result = "result";
    SettableFuture<String> future = SettableFuture.create();
    int[] successCalls = new int[1];
    int[] failureCalls = new int[1];