#define TENSORFLOW_CC_EXPERIMENTAL_LIBTF_RUNTIME_CORE_CORE_H_

#include "tensorflow/cc/experimental/libtf/runtime/runtime.h"

namespace tf {
namespace libtf {
namespace runtime {
namespace core {

// Instantiate a Core Runtime.
Runtime Runtime();

}  // namespace core
}  // namespace runtime
}  // namespace libtf
}  // namespace tf

}

func TestSchedLocalQueue(t *testing.T) {
	runtime.RunSchedLocalQueueTest()
}

func TestSchedLocalQueueSteal(t *testing.T) {
	runtime.RunSchedLocalQueueStealTest()
}

func TestSchedLocalQueueEmpty(t *testing.T) {
	if runtime.NumCPU() == 1 {
		// Takes too long and does not trigger the race.
		t.Skip("skipping on uniprocessor")
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))

  // If `use_tfrt` is true, we will use the new Tensorflow Runtime
  // (https://blog.tensorflow.org/2020/04/tfrt-new-tensorflow-runtime.html) as
  // our runtime implementation.
  RuntimeBuilder& SetUseTFRT(bool use_tfrt);

  // Build a Tensorflow Runtime.
  //
  // Params:
  //  status - Set to OK on success and an appropriate error on failure.
  // Returns:

            "gradle-worker-main-runtime",
            "gradle-launcher-runtime",
            "gradle-cli-runtime",
            "gradle-workers-runtime",
            "gradle-dependency-management-runtime",
            "gradle-plugin-use-runtime",
            "gradle-tooling-api-builders-runtime",
            "gradle-configuration-cache-runtime",
            "gradle-unit-test-fixtures-runtime",
            "plugin1-runtime",

	}()
	i := 0
	println("t2")
	runtime.SetFinalizer(&i, func(p *int) {})
	println("t3")
	runtime.GC()
	println("t4")
	runtime.Goexit()
}

func GoNil() {
	defer func() {
		recover()
	}()
	var f func()
	go f()
	select {}
}

func MainGoroutineID() {
	panic("test")
}

func NoHelperGoroutines() {
	i := 0
	runtime.SetFinalizer(&i, func(p *int) {})

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
	"k8s.io/apimachinery/pkg/runtime/serializer/json"
	"k8s.io/apimachinery/pkg/runtime/serializer/protobuf"
	"k8s.io/apimachinery/pkg/util/dump"
	"k8s.io/apimachinery/pkg/util/sets"
)

type InstallFunc func(scheme *runtime.Scheme)

type Serializer struct {
	meta    MetaFactory
	options SerializerOptions
	creater runtime.ObjectCreater
	typer   runtime.ObjectTyper

	identifier runtime.Identifier
}

// Serializer implements Serializer
var _ runtime.Serializer = &Serializer{}
var _ recognizer.RecognizingDecoder = &Serializer{}

import (
	"bytes"
	"testing"

	"k8s.io/apimachinery/pkg/runtime"
)

func TestSpliceBuffer(t *testing.T) {
	testBytes0 := []byte{0x01, 0x02, 0x03, 0x04}
	testBytes1 := []byte{0x04, 0x03, 0x02, 0x02}

	testCases := []struct {
		name string
		run  func(sb runtime.Splice, buf *bytes.Buffer)
	}{
		{
			name: "Basic Write",
			run: func(sb runtime.Splice, buf *bytes.Buffer) {
				sb.Write(testBytes0)

	# to cgoPackages in cmd/dist/test.go as well.
	RUNTIME
	< C
	< runtime/cgo
	< CGO
	< runtime/msan, runtime/asan;

	# runtime/race
	NONE < runtime/race/internal/amd64v1;
	NONE < runtime/race/internal/amd64v3;
	CGO, runtime/race/internal/amd64v1, runtime/race/internal/amd64v3 < runtime/race;

	# Bulk of the standard library must not use cgo.

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

package race_test

import (
	"runtime"
	"sync"
	"testing"
	"time"
)

func TestNoRaceFin(t *testing.T) {
	c := make(chan bool)
	go func() {
		x := new(string)
		runtime.SetFinalizer(x, func(x *string) {
			*x = "foo"
		})
		*x = "bar"
		c <- true
	}()
	<-c
	runtime.GC()
	time.Sleep(100 * time.Millisecond)
}

var finVar struct {
	sync.Mutex