@pytest.mark.parametrize(
    "path", ["/a/compute", "/a/compute/", "/b/compute", "/b/compute/"]
)
def test_post(path):
    data = {"a": 2, "b": "foo"}
    response = client.post(path, json=data)
    assert response.status_code == 200, response.text
    assert data == response.json()


@pytest.mark.parametrize(
    "path", ["/a/compute", "/a/compute/", "/b/compute", "/b/compute/"]
)
def test_post_invalid(path):

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentToPresent() {
    assertEquals(
        "Map.compute(absent, functionReturningValue) should return value",
        v3(),
        getMap()
            .compute(
                k3(),
                (k, v) -> {
                  assertEquals(k3(), k);
                  assertNull(v);
                  return v3();

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentToPresent() {
    assertEquals(
        "Map.compute(absent, functionReturningValue) should return value",
        v3(),
        getMap()
            .compute(
                k3(),
                (k, v) -> {
                  assertEquals(k3(), k);
                  assertNull(v);
                  return v3();

    // b/80241237

    Cache<String, String> c = CacheBuilder.newBuilder().maximumSize(1).build();

    assertThat(c.asMap().compute("hash-1", (k, v) -> "a")).isEqualTo("a");
    assertThat(c.asMap().compute("hash-1", (k, v) -> "b")).isEqualTo("b");
    assertThat(c.asMap().compute("hash-1", (k, v) -> "c")).isEqualTo("c");
    assertThat(c.size()).isEqualTo(1);
    assertThat(c.asMap().computeIfAbsent("hash-2", k -> "")).isEqualTo("");

from fastapi import APIRouter, Body

router = APIRouter()


@router.post("/compute/")
def compute(a: int = Body(), b: str = Body()):

from fastapi import APIRouter, Body

router = APIRouter()


@router.post("/compute")
def compute(a: int = Body(), b: str = Body()):

}


fun Test.includeSpockAnnotation(fqcn: String) {
    systemProperties.compute("include.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }
}


fun Test.excludeSpockAnnotation(fqcn: String) {
    systemProperties.compute("exclude.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }

  type: KClass<T>,
  compute: () -> T,
): T {
  var computed: T? = null

  while (true) {
    val tags = get()

    // If the element is already present. Return it.
    val existing = tags[type]
    if (existing != null) return existing

    if (computed == null) {
      computed = compute()
    }

    // If we successfully add the computed element, we're done.

  TF_Status* s = TF_NewStatus();
  TF_OpKernelConstruction_GetAttrType(ctx, "foobar", &type, s);
  TF_DeleteStatus(s);
  return NULL;
}

// A compute function. This will never actually get called in this test, it's
// just nice to know that it compiles.
void compute(void* kernel, TF_OpKernelContext* ctx) {
  TF_Tensor* input;
  TF_Status* s = TF_NewStatus();
  TF_GetInput(ctx, 0, &input, s);
  TF_DeleteTensor(input);

export DEBIAN_FRONTEND=noninteractive

# Fetch the NVIDIA key.
apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/3bf863cc.pub;

# Set up sources for NVIDIA CUDNN.
cat >/etc/apt/sources.list.d/nvidia.list <<SOURCES
# NVIDIA
deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/ /