import os
import shutil

from fastapi.testclient import TestClient


def test_main():
    if os.path.isdir("./static"):  # pragma: nocover
        shutil.rmtree("./static")
    if os.path.isdir("./templates"):  # pragma: nocover
        shutil.rmtree("./templates")
    shutil.copytree("./docs_src/templates/templates/", "./templates")
    shutil.copytree("./docs_src/templates/static/", "./static")
    from docs_src.templates.tutorial001 import app

from dirty_equals import IsOneOf
from fastapi.testclient import TestClient

from docs_src.behind_a_proxy.tutorial004 import app

client = TestClient(app)


def test_main():
    response = client.get("/app")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}


def test_openapi_schema():
    response = client.get("/openapi.json")
    assert response.status_code == 200

        "@com_google_absl//absl/log",
        "@com_google_absl//absl/strings",
        "@local_xla//xla:statusor",
    ],
)

cc_library(
    name = "test_util",
    testonly = 1,
    srcs = ["test_util.cc"],
    hdrs = ["test_util.h"],
    deps = [
        ":shape_inference",
        "//tensorflow/core:core_cpu",
        "//tensorflow/core:core_cpu_base",
        "//tensorflow/core:framework",

#include "tensorflow/compiler/mlir/tensorflow/transforms/test_passes.h.inc"

struct FreezeVariableTestPass
    : public impl::FreezeVariablesTestPassBase<FreezeVariableTestPass> {
  void runOnOperation() override {
    TF::test_util::FakeSession session;
    if (tf_saved_model::FreezeVariables(getOperation(), &session).failed())
      signalPassFailure();
  }
};
}  // namespace

#include "tensorflow/c/experimental/stream_executor/stream_executor_test_util.h"

extern "C" {

void SE_InitPlugin(SE_PlatformRegistrationParams* const params,
                   TF_Status* const status) {
  stream_executor::test_util::PopulateDefaultPlatformRegistrationParams(params);
}

void TF_InitKernel() {}

        """
        file("src/test/cpp/test.cpp") << """
            #include <tests.h>
            int test() {
                return 0;
            }
        """
        file("src/test/cpp/test_main.cpp") << """
            #include <tests.h>
            int main() {
                return test();
            }
        """
    }

    @Override
    protected void changeTestImplementation() {

}


def test_openapi_schema_main():
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == openapi_schema_main


def test_main():
    response = client.get("/app")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "Hello World from main app"}


def test_openapi_schema_sub():

#include "tensorflow/core/platform/threadpool_options.h"
#include "tensorflow/core/protobuf/error_codes.pb.h"
#include "tensorflow/core/public/session_options.h"

namespace mlir {
namespace TF {
namespace test_util {
namespace {
using ::tensorflow::Status;
using ::tensorflow::Tensor;

const char kDeviceNamePrefix[] = "/job:worker/replica:0/task:1";
const char kDeviceName[] = "/job:worker/replica:0/task:1/device:CPU:0";

#include "tensorflow/c/experimental/stream_executor/stream_executor_test_util.h"

#include "tensorflow/c/experimental/stream_executor/stream_executor.h"

namespace stream_executor {
namespace test_util {

/*** Functions for creating SP_StreamExecutor ***/
void Allocate(const SP_Device* const device, uint64_t size,
              int64_t memory_space, SP_DeviceMemoryBase* const mem) {}

    : public impl::InitializeVariablesInSessionInitializerPassBase<
          InitializeVariablesInSessionInitializerPass> {
 public:
  void runOnOperation() final {
    static tensorflow::Session* session = new TF::test_util::FakeSession();
    if (failed(tf_saved_model::InitializeVariablesInSessionInitializer(
            getOperation(), session)))
      signalPassFailure();
  }

 private:
};
}  // anonymous namespace