*
 * <ul>
 *   <li>Maintains parent-child relationships between requests to track operation nesting</li>
 *   <li>Carries contextual data describing the current request or operation</li>
 *   <li>Supports both internal session operations and client-provided trace information</li>
 * </ul>
 *
 * <p>For internal session operations, the trace typically contains {@code *Request} objects

    public void test_add_validParameters() {
        TestDataStore dataStore = new TestDataStore("TestStore");
        dataStoreFactory.add("testName", dataStore);

        // Verify data store is registered with both the given name and class simple name
        assertNotNull(dataStoreFactory.getDataStore("testName"));
        assertNotNull(dataStoreFactory.getDataStore("testname")); // case insensitive

				</div>
				<div class="info">
					<fmt:formatDate value="${fe:parseDate(doc.last_modified)}" type="BOTH" pattern="yyyy-MM-dd HH:mm" />
					<c:if test="${doc.last_modified==null || doc.last_modified==''}">
						<fmt:formatDate value="${fe:parseDate(doc.created)}" type="BOTH" pattern="yyyy-MM-dd HH:mm" />
					</c:if>
					<c:if test="${doc.content_length!=null && doc.content_length!=''}">

 * #elementSet} contains the distinct elements of the multiset "with duplicates collapsed", and
 * {@link #entrySet} is similar but contains {@link Entry Multiset.Entry} instances, each providing
 * both a distinct element and the count of that element.
 *
 * <p>In addition to these required methods, implementations of {@code Multiset} are expected to

    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    if (sslSocket is org.openjsse.javax.net.ssl.SSLSocket) {
      when (val protocol = sslSocket.applicationProtocol) {
        // Handles both un-configured and none selected.
        null, "" -> null
        else -> protocol
      }
    } else {
      super.getSelectedProtocol(sslSocket)
    }

  companion object {
    val isSupported: Boolean =

   * default rounding mode: if the two nearest representable values are equally near, the one with
   * the least significant bit zero is chosen. (In such cases, both of the nearest representable
   * values are even integers; this method returns the one that is a multiple of a greater power of
   * two.)
   *

        assertEquals(cause.toString(), exception.getMessage(), "Message should be cause.toString() when only cause is provided");
    }

    @Test
    @DisplayName("Message and cause constructor should preserve both crypto parameters")
    void testMessageAndCauseConstructor() {
        // Given
        NoSuchAlgorithmException cause = new NoSuchAlgorithmException("Algorithm not found");

        // When

        assertEquals(originalString, avTargetName.getTargetName(), "Retrieved target name should correctly decode raw bytes");
    }

    /**
     * Test with an empty string for both constructors.
     */
    @Test
    void testEmptyString() {
        String emptyString = "";
        AvTargetName avTargetNameFromString = new AvTargetName(emptyString);

  }

  override fun handle(socket: Socket) {
    val task = serviceSocketTask(socket.asBufferedSocket())
    results.add(task)
    task.run()
  }

  /** Returns a task that processes both request and response from [socket]. */
  private fun serviceSocketTask(socket: BufferedSocket): FutureTask<Void> {
    return FutureTask<Void> {
      socket.source.use {
        socket.sink.use {
          while (true) {

  /*
   * Previously we had a field named list that was initialized to the value of
   * collection in setUp(), but that caused problems when a tester changed the
   * value of list or collection but not both.
   */
  protected final List<E> getList() {
    return (List<E>) collection;
  }

  /**
   * {@inheritDoc}
   *
   * <p>The {@code AbstractListTester} implementation overrides {@link