* @since 9.0 (in 1.0 as {@code ValueFuture})
 */
@GwtCompatible
public final class SettableFuture<V extends @Nullable Object>
    extends AbstractFuture.TrustedFuture<V> {
  /**
   * Creates a new {@code SettableFuture} that can be completed or cancelled by a later method call.
   */
  public static <V extends @Nullable Object> SettableFuture<V> create() {
    return new SettableFuture<>();
  }

  @CanIgnoreReturnValue
  @Override

            }
        },
        "components": {
            "schemas": {
                "Item": {
                    "title": "Item",
                    "required": ["id", "value"],
                    "type": "object",
                    "properties": {
                        "id": {"title": "Id", "type": "string"},
                        "value": {"title": "Value", "type": "string"},
                    },
                },

            "components": {
                "schemas": {
                    "Body_read_items_items__item_id__put": {
                        "title": "Body_read_items_items__item_id__put",
                        "type": "object",
                        "properties": {
                            "start_datetime": {
                                "title": "Start Datetime",
                                "type": "string",

            }
        },
        "components": {
            "schemas": {
                "HTTPValidationError": {
                    "title": "HTTPValidationError",
                    "type": "object",
                    "properties": {
                        "detail": {
                            "title": "Detail",
                            "type": "array",

                            "type": "array",
                            "title": "Detail",
                        }
                    },
                    "type": "object",
                    "title": "HTTPValidationError",
                },
                "Subscription": {
                    "properties": {
                        "username": {"type": "string", "title": "Username"},

     * }
     */

    Object addr;
    String calledName;

    /**
     * Create a <code>UniAddress</code> by wrapping an {@code InetAddress} or
     * <code>NbtAddress</code>.
     *
     * @param addr
     *            wrapped address
     */
    public UniAddress(final Object addr) {
        if (addr == null) {
            throw new IllegalArgumentException();

      return insertionOrder;
    }

    @Override
    public List<Entry<String, Integer>> create(Object... elements) {
      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
      for (Object o : elements) {
        @SuppressWarnings("unchecked")
        Entry<String, Integer> entry = (Entry<String, Integer>) checkNotNull(o);
        builder.put(entry);

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


@pytest.mark.parametrize(
    "path",
    ["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str):
    client = TestClient(app)
    response = client.post(path)

    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (boost != null) {
            addFieldToSource(sourceMap, "boost", boost);
        }
        if (createdBy != null) {

    private static final Logger log = LoggerFactory.getLogger(DisniRdmaProvider.class);

    // DiSNI components - these would be actual DiSNI objects in a real implementation
    private Object endpointGroup; // RdmaActiveEndpointGroup<DisniRdmaEndpoint>
    private Object endpoint; // RdmaActiveEndpoint
    private boolean initialized = false;

    @Override
    public boolean isAvailable() {
        try {