std::unique_ptr<StaticDeviceMgr> device_mgr_;
  EagerContextPtr ctx_;
};

// Sanity check that constructing a tensorflow::Variable from a SavedVariable
// 1. does not cause an error
// 2. preserves dtype and shape.
TEST_P(SavedVariableLoadingTest, LoadSavedVariableSuccessful) {
  auto& test_params = GetParam();
  DataType dtype = std::get<0>(test_params);
  TensorShape shape(std::get<1>(test_params));

  SavedVariable saved_variable;

      /*ret_def=*/{{"out", "out:output:0"}});
  *fdef_lib.add_function() = std::move(func);
  return fdef_lib;
}

// This tests a rewrite that only makes sense and is active in a CUDA-enabled
// build.  Specifically we check that we insert an IdentityN op to avoid extra
// device-to-host copies.
TEST_F(BuildXlaOpsTest, NoDeviceToHostCopiesForClustersWithInt32Inputs) {
  const char* kXlaDeviceName = "/job:worker/replica:0/task:0/device:GPU:0";

  std::unique_ptr<core::ScopedUnref> mock_profiler_ref_;

  XlaDeviceCompiler* xla_device_compiler_;
  std::unique_ptr<core::ScopedUnref> xla_device_compiler_ref_;
};

TEST_F(DeviceCompilerTest, CompileStrictSuccess) {
  const XlaCompiler::CompilationResult* compilation_result = nullptr;
  xla::LocalExecutable* xla_executable = nullptr;

  XlaCompiler::Options options = GetDefaultXlaOptions();

        assertThat(activation.getRequiredInactiveProfileIds(), containsInAnyOrder("test1", "test2"));
        assertThat(activation.getOptionalInactiveProfileIds(), containsInAnyOrder("test3", "test4"));

        activation = new ProfileActivation();
        performProfileActivation(parser.parse(options, new String[] {"-P", "-test1,+test2"}), activation);

        assertContentType("text/x-csrc", "extractor/program/test.c", "test.c");
        assertContentType("text/x-c++src", "extractor/program/test.cpp", "test.cpp");
        assertContentType("text/x-chdr", "extractor/program/test.h", "test.h");
        assertContentType("text/x-c++hdr", "extractor/program/test.hpp", "test.hpp");
        assertContentType("text/x-java-source", "extractor/program/test.java", "test.java");

#include "tensorflow/core/platform/path.h"
#include "tensorflow/core/platform/test.h"
#include "tensorflow/core/protobuf/trackable_object_graph.pb.h"
#include "tsl/lib/core/status_test_util.h"
#include "tsl/platform/statusor.h"

namespace tensorflow {
namespace {

constexpr char kTestData[] = "cc/saved_model/testdata";

class BundleV2Test : public ::testing::Test {
 protected:
  BundleV2Test() {}

      /*use_pjrt_tensor_buffer=*/false, execute_outputs, context_.get()));

  Tensor* expected = CreateHostTensor<int32>(TensorShape({1, 3}), {5, 7, 9});
  test::ExpectTensorEqual<int32>(*expected, *GetOutput(0));
}

TEST_F(PjRtExecutionUtilTest, PopulateCtxOutputsDynamicShape) {
  XlaOpRegistry::RegisterCompilationKernels();
  TF_EXPECT_OK(NodeDefBuilder("testWhere", "Where")

    func.func @main(%arg0: tensor<1x4x4x3xf32>) -> tensor<1x4x4x3xf32> attributes {_from_xla_call_module} {
      %cst_0 = arith.constant dense<1.0> : tensor<3x1x1x3xf32>
      %cst_1 = arith.constant dense<2.0> : tensor<3xf32>

    }

    def "can register progress loggers for different test workers"() {
        def testWorkerProgressLogger1 = Mock(ProgressLogger)
        def testWorkerProgressLogger2 = Mock(ProgressLogger)

        given:
        def testEvent1 = new TestEvent('Gradle Test Executor 1', 'org.gradle.Test1')
        def testEvent2 = new TestEvent('Gradle Test Executor 2', 'org.gradle.Test2')
        def testDescriptor1 = createTestDescriptor(testEvent1)

def test_multiple_path():
    app = FastAPI()

    @app.get("/test1")
    @app.get("/test2")
    async def test(var: Annotated[str, Query()] = "bar"):
        return {"foo": var}

    client = TestClient(app)
    response = client.get("/test1")
    assert response.status_code == 200
    assert response.json() == {"foo": "bar"}

    response = client.get("/test1", params={"var": "baz"})
    assert response.status_code == 200