* consistent. For example, this method <i>might</i> choose to pass through recognized
   * implementations of {@code PeekingIterator} when the behavior of the implementation is known to
   * meet the contract guaranteed by this method.
   *
   * <p>There is no {@link Iterable} equivalent to this method, so use this method to wrap each
   * individual iterator as it is generated.
   *

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() {

/**
 * 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>

/**
 * 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

   * containing one element (the given set itself).
   *
   * <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.
   *
   * <p>This method is not type-safe, as it may be called on elements that are not mutually
   * comparable.
   *

            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);

   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.
   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
   * to ensure the compiler knows that it will throw.
   *
   * @return this method does not return; it always throws
   * @throws IOException when the given throwable is an IOException

  abstract fun writeTo(sink: BufferedSink)

  /**
   * A duplex request body is special in how it is **transmitted** on the network and
   * in the **API contract** between OkHttp and the application.
   *
   * This method returns false unless it is overridden by a subclass.
   *
   * ### Duplex Transmission
   *
   * With regular HTTP calls the request always completes sending before the response may begin

    private ExecutorService inline = newDirectExecutorService();

    public void assertLastMethodCalled(String method) {
      assertEquals(method, lastMethodCalled);
    }

    public void assertMethodWithTimeout(String method, long timeout, TimeUnit unit) {
      assertLastMethodCalled(method + "Timeout");
      assertEquals(unit.toMillis(timeout), lastTimeoutInMillis);
    }

    @Override

 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations