*/
    public String jobLogging;

    /**
     * Whether the scheduled job is available.
     */
    public String available;

    /**
     * Sort order of the scheduled job.
     */
    public String sortOrder;

    /**
     * The user who created the scheduled job.
     */
    public String createdBy;

    /**

  override fun <T : Any> get(key: KClass<T>): T? =
    when {
      key == this.key -> key.java.cast(value)
      else -> next[key]
    }

  /** Returns a [toString] consistent with [Map], with elements in insertion order. */
  override fun toString(): String =
    generateSequence<LinkedTags<*>>(seed = this) { it.next as? LinkedTags<*> }
      .toList()
      .reversed()

      return emptySet();
    }
  }

  /**
   * Creates a suite whose map has some elements filtered out of view.
   *
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(
      FeatureSpecificTestSuiteBuilder<

  // Package-private so that it can be extended.
  MinimalCollection(Class<? super @NonNull E> type, boolean allowNulls, E... contents) {
    // TODO: consider making it shuffle the contents to test iteration order.
    this.contents = Platform.clone(contents);
    this.type = type;
    this.allowNulls = allowNulls;

    if (!allowNulls) {
      for (Object element : contents) {
        if (element == null) {

  }

  /*
   * The behavior of toString() and iteration is tested by LinkedHashMultiset,
   * which shares a lot of code with HashMultiset and has deterministic
   * iteration order.
   */

                    return new StandardImplForwardingSortedMultiset<>(
                        TreeMultiset.create(asList(elements)));
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {
                    return Ordering.natural().sortedCopy(insertionOrder);
                  }
                })
            .named("ForwardingSortedMultiset with standard impls")

    @Override
    public Double[] createArray(int length) {
      return new Double[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Double> order(List<Double> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleDoubles extends SampleElements<Double> {
    public SampleDoubles() {
      super(0.0, 1.0, 2.0, 3.0, 4.0);

    }

    return derivedSuites;
  }

  /**
   * Creates a suite whose set has some elements filtered out of view.
   *
   * <p>Because the set may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubsetSuite(
      FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>>

  /** The socket that carries this web socket. This is canceled when the web socket fails. */
  private var socket: Socket? = null

  /** Outgoing pongs in the order they should be written. */
  private val pongQueue = ArrayDeque<ByteString>()

  /** Outgoing messages and close frames in the order they should be written. */
  private val messageAndCloseQueue = ArrayDeque<Any>()

 *
 * <p>When dealing with {@link Inet4Address} and {@link Inet6Address} objects as byte arrays (vis.
 * {@code InetAddress.getAddress()}) they are 4 and 16 bytes in length, respectively, and represent
 * the address in network byte order.
 *
 * <p>Examples of IP addresses and their byte representations:
 *
 * <dl>
 *   <dt>The IPv4 loopback address, {@code "127.0.0.1"}.
 *   <dd>{@code 7f 00 00 01}
 *   <dt>The IPv6 loopback address, {@code "::1"}.