measureTime {
          val exception =
            assertFailsWith<IOException> {
              response.trailers()
            }
          assertThat(exception.message).isIn(
            "Socket closed", // HTTP/1.1
            "stream was reset: CANCEL", // HTTP/2
          )
        }
      assertThat(trailersDelay).isGreaterThan(250.milliseconds)
      assertThat(trailersDelay).isLessThan(750.milliseconds)

  }

  @Override
  public ImmutableRangeMap<K, V> subRangeMap(Range<K> range) {
    if (checkNotNull(range).isEmpty()) {
      return ImmutableRangeMap.of();
    } else if (ranges.isEmpty() || range.encloses(span())) {
      return this;
    }
    int lowerIndex =
        SortedLists.binarySearch(
            ranges,
            Range::upperBound,
            range.lowerBound,

            // Setup close to call real method
            doCallRealMethod().when(handle).close();

            // The finally block ensures pipe is closed even if handle close fails
            // Since the real method will propagate the exception from handle.close(),
            // we need to catch it to verify that pipe.close() was still called
            try {

            manager.storeSessionKey("auto-session", testKey, "AES");
            assertTrue(manager.hasSessionKey("auto-session"), "Key should exist");
        }
        // Manager should be closed automatically
    }

    @Test
    public void testSecureWipeUtility() {
        byte[] data = new byte[16];
        new SecureRandom().nextBytes(data);

        // Verify data is not all zeros initially

    clientReaderWithCompression.close()
    assertFailsWith<Exception> {
      clientReaderWithCompression.processNextFrame()
    }.also { expected ->
      assertThat(expected.message!!).contains("closed")
    }
  }

  private fun binaryData(length: Int): ByteString {
    val junk = ByteArray(length)
    random.nextBytes(junk)
    return junk.toByteString()
  }

	public abstract fun newWebSocket (Lokhttp3/Request;Lokhttp3/WebSocketListener;)Lokhttp3/WebSocket;
}

public abstract class okhttp3/WebSocketListener {
	public fun <init> ()V
	public fun onClosed (Lokhttp3/WebSocket;ILjava/lang/String;)V
	public fun onClosing (Lokhttp3/WebSocket;ILjava/lang/String;)V
	public fun onFailure (Lokhttp3/WebSocket;Ljava/lang/Throwable;Lokhttp3/Response;)V

        // This test verifies that close() handles errors gracefully
        CharMappingItem newItem = new CharMappingItem(0, new String[] { "x", "y" }, "z");

        // Insert will trigger MappingUpdater which will be closed automatically
        charMappingFile.insert(newItem);

        // Verify the operation completed successfully despite any internal errors
        PagingList<CharMappingItem> result = charMappingFile.selectList(0, 10);

		}
	}
	if !truncated {
		return entries, io.EOF
	}
	return entries, nil
}

// listMerged will list across all sets and return a merged results stream.
// The result channel is closed when no more results are expected.
func (z *erasureServerPools) listMerged(ctx context.Context, o listPathOptions, results chan<- metaCacheEntry) error {
	var mu sync.Mutex
	var wg sync.WaitGroup
	var errs []error

    }
    // ParameterizedTypeImpl constructor already checks, but we want to throw NPE before IAE
    checkNotNull(arguments);
    checkArgument(rawType.getEnclosingClass() != null, "Owner type for unenclosed %s", rawType);
    return new ParameterizedTypeImpl(ownerType, rawType, arguments);
  }

  /** Returns a type where {@code rawType} is parameterized by {@code arguments}. */

  @SuppressWarnings("unchecked")
  static final ImmutableMap<Object, Object> EMPTY =
      new RegularImmutableMap<>((Entry<Object, Object>[]) ImmutableMap.EMPTY_ENTRY_ARRAY, null, 0);

  /**
   * Closed addressing tends to perform well even with high load factors. Being conservative here
   * ensures that the table is still likely to be relatively sparse (hence it misses fast) while
   * saving space.
   */