expectedParsingErr:    nil,
			expectedValidationErr: nil,
		},
		{ // Using ExpiredObjectAllVersions element with an object locked bucket
			inputConfig: `<LifecycleConfiguration>
                                        <Rule>
                                          <ID>ExpiredObjectAllVersions with object locking</ID>
		                          <Filter>
		                             <Prefix>prefix</Prefix>

    if (t instanceof Error && !(t instanceof StackOverflowError)) {
      throw (Error) t;
    }
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future)
      throws InterruptedException, ExecutionException {
    return future.blockingGet();
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future, long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {

#### Other API changes:

    Object[] builderArray = builder.alternatingKeysAndValues;
    for (int i = 0; i < 10; i++) {
      builder.put(i, i);
    }
    Object[] builderArrayAfterPuts = builder.alternatingKeysAndValues;
    RegularImmutableBiMap<Integer, Integer> map =
        (RegularImmutableBiMap<Integer, Integer>) builder.build();
    Object[] mapInternalArray = map.alternatingKeysAndValues;

mapreduce.task.sort.spill.percent=0.9 # Minimum % before spilling to disk
```

         * @return String
         */
        public String getBbb(final Object a) {
            return null;
        }

        /**
         * @return boolean
         */
        public boolean isCCC() {
            return true;
        }

        /**
         * @return Object
         */
        public Object isDdd() {
            return null;
        }

        /**

                "items": {"type": "string"},
                "title": "P",
                "type": "array",
            },
        },
        "required": ["p"],
        "title": body_model_name,
        "type": "object",
    }


@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
    "path",
    ["/required-list-str", "/model-required-list-str"],
)

        "properties": {
            "p": {
                "anyOf": [{"type": "string"}, {"type": "null"}],
                "title": "P",
            },
        },
        "title": body_model_name,
        "type": "object",
    }


def test_optional_str_missing():
    client = TestClient(app)
    response = client.post("/optional-str")
    assert response.status_code == 200, response.text
    assert response.json() == {"p": None}

   *
   * @return an array containing all of the elements in this queue
   */
  @CanIgnoreReturnValue
  @Override
  public Object[] toArray() {
    E[] items = this.items;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      Object[] a = new Object[count];
      int k = 0;
      int i = takeIndex;
      while (k < count) {
        a[k++] = items[i];
        i = inc(i);
      }

// Copyright (c) 2015-2021 MinIO, Inc.
//
// This file is part of MinIO Object Storage stack
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful