@GwtCompatible
@Immutable(containerOf = {"R", "C", "V"})
final class SparseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
  static final ImmutableTable<Object, Object, Object> EMPTY =
      new SparseImmutableTable<>(ImmutableList.of(), ImmutableSet.of(), ImmutableSet.of());

  private final ImmutableMap<R, ImmutableMap<C, V>> rowMap;

              object : DelegatingSSLSocketFactory(sslSocketFactory) {
                override fun configureSocket(sslSocket: SSLSocket): SSLSocket {
                  return sslSocket.apply {
                    sslParameters =
                      sslParameters.apply {
                        sniMatchers =
                          listOf(
                            object : SNIMatcher(StandardConstants.SNI_HOST_NAME) {

 * for managing object lifecycle and dependencies within Maven's build process.
 * <p>
 * This package provides a set of annotations that control how objects are created,
 * managed and injected throughout Maven's execution lifecycle. The framework is designed
 * to be lightweight yet powerful, supporting various scopes of object lifecycle from
 * singleton instances to mojo-execution-scoped beans.
 * <p>

public class ScriptExecutor extends JobExecutor {

    /**
     * Constructor.
     */
    public ScriptExecutor() {
        super();
    }

    @Override
    public Object execute(final String scriptType, final String script) {
        final Map<String, Object> params = new HashMap<>();
        params.put("executor", this);

        return ComponentUtil.getScriptEngineFactory().getScriptEngine(scriptType).evaluate(script, params);
    }

/**
 * A generator for {@code ListMultimap} implementations based on test data.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestListMultimapGenerator<K extends @Nullable Object, V extends @Nullable Object>

                    {"type": "null"},
                ],
                "title": "P",
            }
        },
        "title": body_model_name,
        "type": "object",
    }


@pytest.mark.parametrize(
    "path",
    [
        "/optional-bytes",
        "/optional-uploadfile",
    ],
)
def test_optional_missing(path: str):
    client = TestClient(app)

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


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

And then you can set the `status_code` in that *temporal* response object.

{* ../../docs_src/response_change_status_code/tutorial001_py39.py hl[1,9,12] *}

And then you can return any object you need, as you normally would (a `dict`, a database model, etc).

And if you declared a `response_model`, it will still be used to filter and convert the object you returned.

                            "title": "Detail",
                            "type": "array",
                        },
                    },
                    "title": "HTTPValidationError",
                    "type": "object",
                },
                "Item": {
                    "properties": {
                        "description": {
                            "anyOf": [
                                {

    assertThat(new FreshValueGenerator().generateFresh(type)).isNull();
  }

  private static void assertValueAndTypeEquals(Object expected, Object actual) {
    assertEquals(expected, actual);
    assertEquals(expected.getClass(), actual.getClass());
  }