*/
    public Builder(Comparator<? super E> comparator) {
      this(comparator, ImmutableCollection.Builder.DEFAULT_INITIAL_CAPACITY);
    }

    /** Creates a new builder with an expected size. */
    @SuppressWarnings("unchecked")
    Builder(Comparator<? super E> comparator, int expectedSize) {
      super(true); // don't construct guts of hash-based set builder

        // setup condition
        cb.query().addOrderBy_SuggestWord_Asc();

        // search

    }

    /**
     * Imports elevate words from a CSV file.
     * Expected CSV format: SuggestWord, Reading, Permissions, Labels, Boost
     *
     * @param reader the Reader containing CSV data to import
     */
    public void importCsv(final Reader reader) {

    //                                                                        ============
    /**
     * Verify the CRUD mode.
     * @param crudMode The CRUD mode.
     * @param expectedMode The expected mode.
     * @param dictId The dictionary ID.
     */
    protected void verifyCrudMode(final int crudMode, final int expectedMode, final String dictId) {
        if (crudMode != expectedMode) {

  }

  private fun makeSynchronousCall(call: Call): Thread {
    val thread =
      Thread {
        try {
          call.execute()
          throw AssertionError()
        } catch (expected: IOException) {
        }
      }
    thread.start()
    return thread
  }

  private fun newRequest(url: String): Request = Request.Builder().url(url).build()

  private fun newRequest(

	// if no explicit GenerateKeyRequest.Name is provided.
	DefaultKey string

	conn conn // Connection to the KMS

	// Metrics
	reqOK, reqErr, reqFail atomic.Uint64
	latencyBuckets         []time.Duration // expected to be sorted
	latency                []atomic.Uint64
}

// Version returns version information about the KMS.
//
// TODO(aead): refactor this API call since it does not account
// for multiple KMS/KES servers.

func RegisterError(f func(string, error, bool) string) {
	errorFmtFunc = f
}

// uniq swaps away duplicate elements in data, returning the size of the
// unique set. data is expected to be pre-sorted, and the resulting set in
// the range [0:size] will remain in sorted order. Uniq, following a
// sort.Sort call, can be used to prepare arbitrary inputs for use as sets.

        throw thrown;
      }
    }
  }

  private static void assertExecutionException(Future<?> future, Exception expectedCause)
      throws Exception {
    try {
      future.get();
      fail("Expected ExecutionException");
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().isSameInstanceAs(expectedCause);
    }
  }

  /** invokeAny(null) throws NPE */

            assertNotNull(request);
            assertTrue(request instanceof CreateContextRequest);
        }

        @Test
        @DisplayName("getName() should return expected byte array")
        void testGetNameMethod() {
            byte[] expectedName = "TEST_CONTEXT".getBytes(StandardCharsets.UTF_8);
            CreateContextRequest request = mock(CreateContextRequest.class);

            List<PluginUpgrade> upgrades = PluginUpgradeStrategy.getPluginUpgrades();

            assertFalse(upgrades.isEmpty(), "Should have predefined plugin upgrades");

            // Verify some expected plugins are included
            boolean hasCompilerPlugin =
                    upgrades.stream().anyMatch(upgrade -> "maven-compiler-plugin".equals(upgrade.artifactId()));
            boolean hasExecPlugin =

Using the **SNI extension** discussed above, the TLS Termination Proxy would check which of the TLS (HTTPS) certificates available it should use for this connection, using the one that matches the domain expected by the client.

In this case, it would use the certificate for `someapp.example.com`.

<img src="/img/deployment/https/https03.drawio.svg">