* the format specified by RFC 3986 section 3.2.2.
   *
   * <p>This method is similar to {@link InetAddresses#forString(String)}, however, it requires that
   * IPv6 addresses are surrounded by square brackets.
   *
   * <p>This method is the inverse of {@link InetAddresses#toUriString(java.net.InetAddress)}.
   *
   * <p>This method accepts non-ASCII digits, for example {@code "１９２.１６８.０.１"} (those are fullwidth

 *       so) before returning from the method. The {@code joinPool} method can be used to do this
 *       when using Executors.
 * </ol>
 *
 * <p><b>Other notes</b>
 *
 * <ul>
 *   <li>Usually, there is one testcase method per JSR166 method covering "normal" operation, and
 *       then as many exception-testing methods as there are exceptions the method can throw.

     * not in {@link #nextElements}, this method throws an {@link UnknownElementException}.
     *
     * <p>This method is used when testing iterators without a known ordering. We poll the target
     * iterator's next element and pass it to the reference iterator through this method so it can
     * return the same element. This enables the assertion to pass and the reference iterator to

        .build(),
    )
    val response = client.newCall(request().build()).execute()
    assertThat(response.body).isNotNull()
    response.body.bytes()
    logRecorder
      .assertLogMatch(Regex("""callStart: Request\{method=GET, url=$url\}"""))
      .assertLogMatch(Regex("""proxySelectStart: $url"""))
      .assertLogMatch(Regex("""proxySelectEnd: \[DIRECT]"""))
      .assertLogMatch(Regex("""dnsStart: ${url.host}"""))

   * test*Hole to permit IAE. (But might this ignore genuine bugs?) But see the TODO above
   * testLower, which could make this all unnecessary
   */
  public static Method[] getHoleMethods() {
    return new Method[] {
      getMethod(NavigableSetNavigationTester.class, "testLowerHole"),
      getMethod(NavigableSetNavigationTester.class, "testFloorHole"),

    // -----------/
    // - Methods -/
    // -----------/

    /**
     * Method addLifecycle.
     *
     * @param lifecycle a lifecycle object.
     */
    public void addLifecycle(Lifecycle lifecycle) {
        getLifecycles().add(lifecycle);
    } // -- void addLifecycle( Lifecycle )

    /**
     * Method getLifecycles.
     *
     * @return List
     */

import static org.junit.Assert.assertThat;

import org.junit.Test;

/**
 * @author wyukawa
 *
 */
public class SUnsupportedOperationExceptionTest {

    /**
     * Test method for
     * {@link org.codelibs.core.exception.ClUnsupportedOperationException#SUnsupportedOperationException()}
     * .
     */
    @Test
    public void testSUnsupportedOperationException() {

/**
 * Marks an event subscriber method as being thread-safe. This annotation indicates that EventBus
 * may invoke the event subscriber simultaneously from multiple threads.
 *
 * <p>This does not mark the method, and so should be used in combination with {@link Subscribe}.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ElementTypesAreNonnullByDefault

/**
 * Basic implementation of the {@link SortedSetMultimap} interface. It's a wrapper around {@link
 * AbstractMapBasedMultimap} that converts the returned collections into sorted sets. The {@link
 * #createCollection} method must return a {@code SortedSet}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class AbstractSortedSetMultimap<K extends @Nullable Object, V extends @Nullable Object>

            builder.field(STATUS, status);
        }
        if (httpStatusCode != null) {
            builder.field(HTTP_STATUS_CODE, httpStatusCode);
        }
        if (method != null) {
            builder.field(METHOD, method);
        }
        if (mimeType != null) {
            builder.field(MIME_TYPE, mimeType);
        }
        if (createTime != null) {
            builder.field(CREATE_TIME, createTime);