* value in the manner of {@link Number#shortValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *
   * @param collection a collection of {@code Number} instances

   * that this method will return a different number of chars than would be returned by reading all
   * of the chars.
   *
   * <p>Additionally, for mutable sources such as {@code StringBuilder}s, a subsequent read may
   * return a different number of chars if the contents are changed.
   *
   * @since 19.0
   */
  public Optional<Long> lengthIfKnown() {

   * value in the manner of {@link Number#shortValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *
   * @param collection a collection of {@code Number} instances

	result, err := obj.ListObjects(context.Background(), "bucket", "", "", "", 0)
	if err != nil {
		t.Fatalf("%s: <ERROR> %s", instanceType, err)
	}
	if len(result.Objects) != 0 {
		t.Errorf("%s: Number of objects in the result different from expected value.", instanceType)
	}
	if result.IsTruncated {
		t.Errorf("%s: Expected IsTruncated to be `false`, but instead found it to be `%v`", instanceType, result.IsTruncated)
	}

# Disable sign-off checking for members of the Gradle GitHub organization
require:

                        "age": {
                            "title": "Age",
                            "anyOf": [
                                {"exclusiveMinimum": 0.0, "type": "number"},
                                IsOneOf(
                                    # pydantic < 2.12.0
                                    {"type": "string"},
                                    # pydantic >= 2.12.0

          URISyntaxException.class);

  @Param Validator validator;
  @Param Result result;
  @Param ExceptionType exceptionType;

  /**
   * The number of other exception types in the cache of known-good exceptions and the number of
   * other {@code ClassValue} entries for the exception type to be tested. This lets us evaluate

			errCode = ErrInvalidMaxParts
			return uploadID, partNumberMarker, maxParts, encodingType, errCode
		}
	} else {
		maxParts = maxPartsList
	}

	if values.Get("part-number-marker") != "" {
		if partNumberMarker, err = strconv.Atoi(values.Get("part-number-marker")); err != nil {
			errCode = ErrInvalidPartNumberMarker
			return uploadID, partNumberMarker, maxParts, encodingType, errCode
		}
	}

   * instead of {@code Comparator<? super T>}.
   */
  public void testMinMaxWithSupertypeComparator() {
    Comparator<Number> numberComparator = comparing(Number::intValue);
    Integer comparand1 = 1;
    Integer comparand2 = 2;

    Integer min = min(comparand1, comparand2, numberComparator);
    Integer max = max(comparand1, comparand2, numberComparator);

		return nil
	}
	return e.EncodeElement(tDate.Format(time.RFC3339), startElement)
}

// TransitionDays is a type alias to unmarshal Days in Transition
type TransitionDays int

// UnmarshalXML parses number of days from Transition and validates if
// >= 0
func (tDays *TransitionDays) UnmarshalXML(d *xml.Decoder, startElement xml.StartElement) error {
	var days int
	err := d.DecodeElement(&days, &startElement)
	if err != nil {