* with Chrome's behavior (which also experimentally seems to match what IE does), but if you
     * actually want to have a good chance of things working, please avoid double-quotes, newlines,
     * percent signs, and the like in your field names.
     */
    internal fun StringBuilder.appendQuotedString(key: String) {
      append('"')
      for (i in 0 until key.length) {

      assertTrue(segment.table.length() > i);
    }
  }

  public void testSegmentPut_evict() {
    int maxSize = 10;
    LocalCache<Object, Object> map =
        makeLocalCache(createCacheBuilder().concurrencyLevel(1).maximumSize(maxSize));

    // manually add elements to avoid eviction
    int originalCount = 1024;
    LinkedHashMap<Object, Object> originalMap = new LinkedHashMap<>();

   * {@link Builder} and call {@link Builder#orderRowsBy}, {@link Builder#orderColumnsBy}, and
   * {@link Builder#putAll}
   *
   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   */

    @Override
    public void setUp() throws Exception {
        super.setUp();
        testEnv = new Hashtable<>();
        testEnv.put("test.key", "test.value");
        ldapUser = new LdapUser(testEnv, "testuser");

        ComponentUtil.register(new SystemHelper(), "systemHelper");

        // Register a mock LdapManager to avoid NPE
        ComponentUtil.register(new LdapManager() {

  /**
   * Returns a successful {@code ListenableFuture<Void>}. This method is equivalent to {@code
   * immediateFuture(null)} except that it is restricted to produce futures of type {@code Void}.
   *
   * @since 29.0
   */
  @SuppressWarnings("unchecked")
  public static ListenableFuture<@Nullable Void> immediateVoidFuture() {
    return (ListenableFuture<@Nullable Void>) ImmediateFuture.NULL;
  }

  /**

  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testStringConverterSerialization() {
    SerializableTester.reserializeAndAssert(Longs.stringConverter());
  }

  public void testToArray() {
    // need explicit type parameter to avoid javac warning!?
    List<Long> none = Arrays.<Long>asList();
    assertThat(Longs.toArray(none)).isEqualTo(EMPTY);

    assertThat(dim1 * dim2).isAtLeast(0);
    testConcatOverflow(dim1, dim2);
  }

  private static void testConcatOverflow(int arraysDim1, int arraysDim2) {
    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    double[][] arrays = new double[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    double[] sharedArray = new double[arraysDim2];

  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testStringConverterSerialization() {
    SerializableTester.reserializeAndAssert(Shorts.stringConverter());
  }

  public void testToArray() {
    // need explicit type parameter to avoid javac warning!?
    List<Short> none = Arrays.<Short>asList();
    assertThat(Shorts.toArray(none)).isEqualTo(EMPTY);

     *            {@link PropertyDesc}
     */
    protected void addPropertyDesc(final PropertyDescImpl propertyDesc) {
        assertArgumentNotNull("propertyDesc", propertyDesc);
        propertyDescCache.put(propertyDesc.getPropertyName(), propertyDesc);
    }

    /**
     * Prepares the constructors.
     */
    protected void setupConstructorDescs() {

        }
      } else if (!isMultiplexed || e is ConnectionShutdownException) {
        noNewExchangesEvent = !noNewExchanges
        noNewExchanges = true

        // If this route hasn't completed a call, avoid it for new connections.
        if (successCount == 0) {
          if (e != null) {
            connectFailed(call.client, route, e)
          }
          routeFailureCount++
        }
      }