*       Some methods may have stronger guarantees.
   *   <li>INSERTION: insertion ordering is guaranteed.
   *   <li>SORTED: ordering according to a supplied comparator is guaranteed.
   * </ul>
   */
  public enum Type {
    UNORDERED,
    STABLE,
    INSERTION,
    SORTED
  }

  private ElementOrder(Type type, @CheckForNull Comparator<T> comparator) {
    this.type = checkNotNull(type);
    this.comparator = comparator;

////

In this case, there are 3 query parameters:

* `needy`, a required `str`.
* `skip`, an `int` with a default value of `0`.
* `limit`, an optional `int`.

/// tip

You could also use `Enum`s the same way as with [Path Parameters](path-params.md#predefined-values){.internal-link target=_blank}.

	public final fun getTlsVersion ()Lokhttp3/TlsVersion;
	public final fun getUtf8Body ()Ljava/lang/String;
	public fun toString ()Ljava/lang/String;
}

public final class okhttp3/mockwebserver/SocketPolicy : java/lang/Enum {
	public static final field CONTINUE_ALWAYS Lokhttp3/mockwebserver/SocketPolicy;
	public static final field DISCONNECT_AFTER_REQUEST Lokhttp3/mockwebserver/SocketPolicy;

  public static <E> MultisetTestSuiteBuilder<E> using(TestMultisetGenerator<E> generator) {
    return new MultisetTestSuiteBuilder<E>().usingGenerator(generator);
  }

  public enum NoRecurse implements Feature<Void> {
    NO_ENTRY_SET;

    @Override
    public Set<Feature<? super Void>> getImpliedFeatures() {
      return emptySet();
    }
  }

        public int increment() {
            return count.incrementAndGet();
        }

        public int decrement() {
            return count.decrementAndGet();
        }
    }

    public enum StatsAction {
        ACCESSED, //
        ACCESS_EXCEPTION, //
        CHILD_URL, //
        CHILD_URLS, //
        EVALUATED, //
        EXCEPTION, //
        FINISHED, //
        PARSED, //

   * java.util.Arrays#equals(byte[], byte[])}.
   *
   * @since 2.0
   */
  public static Comparator<byte[]> lexicographicalComparator() {
    return LexicographicalComparator.INSTANCE;
  }

  private enum LexicographicalComparator implements Comparator<byte[]> {
    INSTANCE;

    @Override
    public int compare(byte[] left, byte[] right) {
      int minLength = Math.min(left.length, right.length);

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package event

import (
	"encoding/json"
	"encoding/xml"
)

// Name - event type enum.
// Refer http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html#notification-how-to-event-types-and-destinations

			defer PutByteBuffer(payload)
			return append(GetByteBuffer()[:0], payload...), nil
		}))
		errFatal(rpc.Register(remote, func(req *testRequest) (resp *testResponse, err *RemoteErr) {
			return &testResponse{
				OrgNum:    req.Num,
				OrgString: req.String,
				Embedded:  *req,
			}, nil
		}))
		errFatal(err)
	}
	const payloadSize = 512
	rng := rand.New(rand.NewSource(time.Now().UnixNano()))

                  }

                  Thread.yield();
                }
              }
            });
  }

  /** Enum defining the two MoreFiles methods that delete directory contents. */
  private enum DirectoryDeleteMethod {
    DELETE_DIRECTORY_CONTENTS {
      @Override
      public void delete(Path path, RecursiveDeleteOption... options) throws IOException {

   * ordering, if Spliterator.ORDERED is not present).
   */
  @IgnoreJRERequirement // *should* be redundant with the annotation on SpliteratorTester
  enum SpliteratorDecompositionStrategy {
    NO_SPLIT_FOR_EACH_REMAINING {
      @Override
      <E extends @Nullable Object> void forEach(
          GeneralSpliterator<E> spliterator, Consumer<? super E> consumer) {