/** The pre-generated job log ID. Null when job logging is disabled. */
        protected String jobLogId;

        /**
         * Default constructor for ApiStartJobResponse.
         */
        public ApiStartJobResponse() {
            super();
        }

        /**
         * Sets the job log ID.
         * @param jobLogId The job log ID to set. Null when job logging is disabled.

    @ValidateTypeFailure
    public Integer sortOrder;

    /** The user who created this file configuration (maximum 1000 characters). */
    @Size(max = 1000)
    public String createdBy;

    /** The timestamp when this file configuration was created. */
    @ValidateTypeFailure
    public Long createdTime;

    /**
     * Initializes the form with default values for creation mode.
     */
    public void initialize() {

   * Opens a new buffered {@link OutputStream} for writing to this sink. The returned stream is not
   * required to be a {@link BufferedOutputStream} in order to allow implementations to simply
   * delegate to {@link #openStream()} when the stream returned by that method does not benefit from
   * additional buffering (for example, a {@code ByteArrayOutputStream}). This method returns a new,
   * independent stream each time it is called.
   *

    assertTrue(multimap.replaceValues("foo", asList(2, 4)) instanceof RandomAccess);
    assertTrue(multimap.replaceValues("bar", asList(2, 4)) instanceof RandomAccess);
  }

  /** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */
  public void testSublistConcurrentModificationException() {
    ListMultimap<String, Integer> multimap = create();
    multimap.putAll("foo", asList(1, 2, 3, 4, 5));

    private final HandleType type;

    /**
     * The timeout in milliseconds for durable handles (not applicable for persistent handles)
     */
    private final long timeout;

    /**
     * The timestamp when this handle was created
     */
    private final long createTime;

    /**
     * The timestamp of the last access to this handle
     */
    private volatile long lastAccessTime;

    /**

			expectedErr: errors.New("MasterKeyID is allowed with aws:kms only"),
			shouldPass:  false,
		},
		// 5. Invalid XML - master key ID not provided when algorithm is set to aws:kms algorithm
		{

  }

  /**
   * A predicate that is expected to return true subsequent to finalization, that is, one
   * of the following actions taken by the garbage collector when performing a full collection in
   * response to {@link System#gc()}:
   *
   * <ul>
   *   <li>invoking the {@code finalize} methods of unreachable objects
   *   <li>clearing weak references to unreachable referents

            classes[i] = arg == null ? null : arg.getClass();
        }

        return getMostSpecific(methodList, classes);
    }

    /**
     * simple distinguishable exception, used when
     * we run across ambiguous overloading
     */
    static class AmbiguousException extends Exception {

        private static final long serialVersionUID = 751688436639650618L;
    }

			dataDir = ddir
		}
	}

	if maxCnt >= writeQuorum {
		return dataDir
	}

	return ""
}

// Returns number of errors that occurred the most (incl. nil) and the
// corresponding error value. NB When there is more than one error value that
// occurs maximum number of times, the error value returned depends on how
// golang's map orders keys. This doesn't affect correctness as long as quorum

                        .filter(isStaticClass.negate())
                        .filter(isPublicClass)
                        .filter(isAbstractClass.negate())
                        .filter(this::seemsLikeATest) // TODO when base classes are set, check for classes that extend them
                        .filter(((Predicate<Class<?>>) this::implementsNamingConvention).negate())
                ),