apply plugin: "java"

version = 1.0
group = "test.group"

publishing {
    repositories {
        ivy { url uri("ivy-repo") }
        maven { url uri("maven-repo") }
    }
    publications {
        mainIvy(IvyPublication) {
            from components.java
            organisation 'test.org'
            module 'test-module'
            revision '1.1'
        }
        mainMaven(MavenPublication) {

# Dependencies - `Depends()` and `Security()`

## `Depends()`

Dependencies are handled mainly with the special function `Depends()` that takes a callable.

Here is the reference for it and its parameters.

You can import it directly from `fastapi`:

```python
from fastapi import Depends
```

::: fastapi.Depends

## `Security()`

# In addition to the above, test to make sure there is no funny
# business if we try "go test -cover" in atomic mode targeting
# sync/atomic itself (see #57445). Just a short test run is needed
# since we're mainly interested in making sure the test builds and can
# execute at least one test.

go test -short -covermode=atomic -run=TestStoreInt64 sync/atomic
go test -short -covermode=atomic -run=TestAnd8 internal/runtime/atomic

import org.junit.Assert
import org.junit.Test

/**
 * Simplified from
 * https://hc.apache.org/httpcomponents-client-5.0.x/httpclient5/examples/AsyncClientTlsAlpn.java
 *
 * Mainly intended to verify behaviour of popular clients across Android versions, similar
 * to observing Firefox or Chrome browser behaviour.
 */
class ApacheHttpClientHttp2Test {
  @Test
  fun testHttp2() {

using ::stablehlo::quantization::io::CreateTmpDir;
using ::testing::HasSubstr;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;

// Test cases for `RunQuantization` mainly tests for error cases because testing
// for successful cases require passing python implementation to
// `quantization_py_function_lib`, which requires testing from the python level.

#include "tensorflow/core/framework/device_base.h"

namespace tensorflow {

// tensorflow::PjRtBaseDevice replaces the deprecated tensorflow::XlaDevice.
// This accelerator agnostic device is mainly used to store metadata.
class PjRtBaseDevice : public LocalDevice {
 public:
  // Stores metadata about the PjRtBaseDevice.
  class Metadata {
   public:
    Metadata(const DeviceType& jit_device_type,

        return new StripedProducerGuard<T>();
    }

    /**
     * Creates a {@link ProducerGuard} which limits concurrency to a single factory at a time,
     * ignoring the key. This is mainly useful for testing.
     */
    public static <T> ProducerGuard<T> serial() {
        return new SerialProducerGuard<T>();
    }

    private ProducerGuard() {

    }

    /**

import static org.apache.maven.api.services.BaseRequest.nonNull;

/**
 * Provides access to the contents of a source independently of the
 * backing store (e.g. file system, database, memory).
 * <p>
 * This is mainly used to parse files into objects such as
 * {@link org.apache.maven.api.Project},
 * {@link org.apache.maven.api.model.Model},
 * {@link org.apache.maven.api.settings.Settings}, or

// The initial setting is 1 GB on 64-bit systems, 250 MB on 32-bit systems.
// There may be a system-imposed maximum stack limit regardless
// of the value provided to SetMaxStack.
//
// SetMaxStack is useful mainly for limiting the damage done by
// goroutines that enter an infinite recursion. It only limits future
// stack growth.
func SetMaxStack(bytes int) int {
	return setMaxStack(bytes)
}

   * is complete. It does so by using daemon threads and adding a shutdown hook to wait for their
   * completion.
   *
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *
   * @param executor the executor to modify to make sure it exits when the application is finished