assertTrue("Listener called before it was expected", expectCall);
      assertFalse("Listener called more than once", wasCalled());
      called.set(true);
    }

    void expectCall() {
      assertFalse("expectCall is already true", expectCall);
      expectCall = true;
    }

    boolean wasCalled() {
      return called.get();
    }
  }

  public void testAllAsList() throws Exception {

      assertTrue("Listener called before it was expected", expectCall);
      assertFalse("Listener called more than once", wasCalled());
      called.set(true);
    }

    void expectCall() {
      assertFalse("expectCall is already true", expectCall);
      expectCall = true;
    }

    boolean wasCalled() {
      return called.get();
    }
  }

  public void testAllAsList() throws Exception {

    /**
     * Checks if a previous page exists for pagination.
     *
     * @return true if a previous page exists, false otherwise
     */
    public boolean isExistPrePage() {
        return existPrePage;
    }

    /**
     * Sets the flag indicating whether a previous page exists.
     *
     * @param existPrePage true if a previous page exists, false otherwise
     */

    ["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
        [
            {
                "required": True,
                "schema": {"title": "P", "type": "string"},
                "name": "p",
                "in": "query",
            }
        ]
    )


@pytest.mark.parametrize(
    "path",

			status: scanStateNone,
		}
	}

	// Create new and add.
	best := o.newMetacache()
	b.caches[o.ID] = best
	b.cachesRoot[best.root] = append(b.cachesRoot[best.root], best.id)
	b.updated = true
	b.debugf("returning new cache %s, bucket: %v", best.id, best.bucket)
	return best
}

// cleanup removes redundant and outdated entries.
func (b *bucketMetacache) cleanup() {
	// Entries to remove.

  for (const auto& attr : node_def.attr()) {
    if (attr.first == "dtype") {
      if (attr.second.type() == tensorflow::DT_INT32) {
        found_dtype = true;
      } else {
        return false;
      }
    } else if (attr.first == "shape") {
      found_shape = true;
    }
  }
  return found_dtype && found_shape;
}

bool IsScalarConst(const tensorflow::NodeDef& node_def, int v) {

        final TimestampConverter converter = new TimestampConverter("yyyy/MM/dd");
        assertThat(converter.isTarget(java.sql.Timestamp.class), is(true));
        assertThat(converter.isTarget(java.util.Date.class), is(not(true)));
    }

class Product(BaseModel):
    name: str
    price: float


class Shop(BaseModel):
    name: str


@app.post("/products")
async def create_product(data: Product = Body(media_type=media_type, embed=True)):
    pass  # pragma: no cover


@app.post("/shops")
async def create_shop(
    data: Shop = Body(media_type=media_type),
    included: list[Product] = Body(default=[], media_type=media_type),
):

          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {
            @Throws(IOException::class)
            override fun close() {
              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    assertThat(body.string()).isEqualTo("hello")
    assertThat(closed.get()).isTrue()
  }

  @Test

certificate from .Values.tls.certSecret. trustedCertsSecret: "" ## Enable persistence using Persistent Volume Claims ## ref: http://kubernetes.io/docs/user-guide/persistent-volumes/ ## persistence: enabled: true annotations: {} ## A manually managed Persistent Volume and Claim ## Requires persistence.enabled: true ## If defined, PVC must be created manually before volume will be bound existingClaim: "" ## minio data Persistent Volume Storage Class ## If defined, storageClassName: <storageClass> ## If set to...