#include "tensorflow/core/platform/env.h"
#include "tensorflow/core/platform/test.h"
#include "tensorflow/core/protobuf/meta_graph.pb.h"
#include "tensorflow/core/protobuf/saved_object_graph.pb.h"
#include "tsl/platform/status_matchers.h"

namespace tensorflow {
namespace saved_model {
namespace {

using tsl::testing::StatusIs;

TEST(UtilTest, TestGetWriteVersionV2) {
  SavedModel saved_model_proto;

    }
    return absl::OkStatus();
  }

  DialectRegistry registry_;
  MLIRContext context_;
  OwningOpRef<mlir::ModuleOp> mlir_module_;
};

TEST_F(FunctionClusterTensorflowDialectTest, ClustersTfReplicatedBridge) {
  CellReader<int64_t> compilation_status(kCompilationStreamz);

  TF_ASSERT_OK(CreateMlirModule("empty_func.mlir"));

#include "tensorflow/core/platform/test.h"
#include "tensorflow/core/protobuf/meta_graph.pb.h"

namespace mlir::quant {
namespace {

using ::tensorflow::AssetFileDef;
using ::testing::Eq;
using ::testing::IsEmpty;
using ::testing::IsNull;
using ::testing::NotNull;
using ::testing::SizeIs;

class ConvertAssetArgsTest : public ::testing::Test {
 protected:
  ConvertAssetArgsTest() {

        System.out.println("TestFactory[" + data + "].beforeClass()");
    }

    @Test
    public void test1() {
        System.out.println("TestFactory[" + data + "].test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {
        System.out.println("TestFactory[" + data + "].test2()");
    }

    @AfterClass
    public void afterClass() {

# then it will try to load sleepybad, which does not compile,
# and the test command will fail.
! go list m/sleepy...
go test -c -n -coverprofile=$TMPDIR/cover.out -coverpkg=m/sleepy... -run=^$ m/sleepy1

-- go.mod --
module m

go 1.16
-- sleepy1/p_test.go --
package p

import (
	"testing"
	"time"
)

func Test1(t *testing.T) {
	time.Sleep(200 * time.Millisecond)
}
-- sleepy2/p_test.go --

// license that can be found in the LICENSE file.

package main

func main() {
	test1()
	test2()
}

type I interface {
	f()
	g()
	h()
}

//go:noinline
func ld[T any]() {
	var x I
	if _, ok := x.(T); ok {
	}
}

func isI(x any) {
	_ = x.(I)
}

func test1() {
	defer func() { recover() }()
	ld[bool]() // add <bool,I> itab to binary
	_ = any(false).(I)
}

namespace mlir::quant::stablehlo {
namespace {

using ::testing::Test;

class StablehloTypeUtilsTest : public Test {
 protected:
  StablehloTypeUtilsTest() {
    ctx_.loadDialect<mlir::stablehlo::StablehloDialect,
                     mlir::arith::ArithDialect, mlir::func::FuncDialect>();
  }

  MLIRContext ctx_;
  OpBuilder builder_{&ctx_};
};

TEST_F(StablehloTypeUtilsTest, IsStablehloOpSucceedsWithStablehloOp) {

}

TEST_F(RestoreOpsTest, BadCheckpointPrefixShouldFail) {
  ImmediateTensorHandlePtr x_handle;
  Status status = internal::SingleRestore(
      context(), CheckpointPrefix("unknown_bad_checkpoint_prefix"),
      "x/.ATTRIBUTES/VARIABLE_VALUE", DT_FLOAT, &x_handle);
  EXPECT_FALSE(status.ok()) << status.message();
}

TEST_F(RestoreOpsTest, BadCheckpointKeyShouldFail) {

func test2helper() {
	for i := 0; i < 10; i++ {
		defer addDotDotDot(i)
	}
}

func test2() {
	result = ""
	test2helper()
	if result != "9876543210" {
		fmt.Printf("test2: bad defer result (should be 9876543210): %q\n", result)
		panic("defer")
	}
}

func main() {
	test1()
	test2()

        when:
        grammar("Test1", "Test2")
        then:
        succeeds("generateGrammarSource")

        test1TokenFile.exists()
        test1LexerFile.exists()
        test1ParserFile.exists()

        test2TokenFile.exists()
        test2LexerFile.exists()
        test2ParserFile.exists()

        when:
        removedGrammar("Test1")

        then: