}

    boolean testClassExists(String testClass) {
        throw new UnsupportedOperationException("Unsupported. Implement if you need it.")
    }

    boolean testClassDoesNotExist(String testClass) {
        throw new UnsupportedOperationException("Unsupported. Implement if you need it.")
    }

    TestClassExecutionResult testClass(String testClass) {
        parseResults()

var i0 I0 = t0(0) // ok
var i1 I1 = t1(0) // ok

var i2 I0 = t1(0) // ERROR "does not implement|incompatible"
var i3 I1 = t0(0) // ERROR "does not implement|incompatible"

var p0i p0.I = t0(0) // ok
var p1i p1.I = t1(0) // ok

var p0i1 p0.I = t1(0) // ERROR "does not implement|incompatible"
var p0i2 p1.I = t0(0) // ERROR "does not implement|incompatible"

func foobar() {
	// check that cannot assign one to the other,

    /**
     * {@inheritDoc}
     *
     * @deprecated This class will no longer implement {@link SelfResolvingDependency} in Gradle 9.0.
     */
    @Override
    @Deprecated
    TaskDependency getBuildDependencies();

    /**
     * {@inheritDoc}
     *
     * @deprecated This class will no longer implement {@link SelfResolvingDependency} in Gradle 9.0. Use {@link #getFiles()} instead.
     */
    @Override

		return &o
	}
	return nil
}

// nolint: unused // (not true, its to implement an interface)
func (s *staticList[T]) name() string {
	return "staticList"
}

// nolint: unused // (not true, its to implement an interface)
func (s *staticList[T]) uid() collectionUID {
	return s.id
}

// nolint: unused // (not true, its to implement an interface)
func (s *staticList[T]) dump() {
}

	return eic.run()
}

func (eic *execInContainer) Output() ([]byte, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (eic *execInContainer) SetDir(dir string) {
	// unimplemented
}

func (eic *execInContainer) SetStdin(in io.Reader) {
	// unimplemented
}

func (eic *execInContainer) SetStdout(out io.Writer) {
	eic.writer = out
}

namespace tf_random_access_file {

// TODO(b/139060984): Implement later

}  // namespace tf_random_access_file

// SECTION 2. Implementation for `TF_WritableFile`
// ----------------------------------------------------------------------------
namespace tf_writable_file {

// TODO(b/139060984): Implement later

}  // namespace tf_writable_file

  Status Create(const tensorflow::GraphDef& graph) override {
    return tensorflow::errors::Unimplemented("not available");
  }
  Status Extend(const tensorflow::GraphDef& graph) override {
    return tensorflow::errors::Unimplemented("not available");
  }

  Status Close() override {
    return tensorflow::errors::Unimplemented("not available");
  }

  Status ListDevices(

}

func (s Static) Prefix() string {
	return string(s)
}

func (s Static) Labels() (map[string]string, error) {
	panic("implement me")
}

func (s Static) SetLabel(key, value string) error {
	panic("implement me")
}

func (s Static) RemoveLabel(key string) error {
	panic("implement me")
}

func (s Static) IsAmbient() bool {
	return strings.Contains(string(s), "ambient")
}

type UUIDHash struct {
	uuid []byte
}

// Write -  implement hash.Hash Write
func (u UUIDHash) Write(p []byte) (n int, err error) {
	return len(p), nil
}

// Sum -  implement md5.Sum
func (u UUIDHash) Sum(b []byte) []byte {
	return u.uuid
}

// Reset -  implement hash.Hash Reset
func (u UUIDHash) Reset() {
	return
}

// Size -  implement hash.Hash Size
func (u UUIDHash) Size() int {

#ifdef __cplusplus
extern "C" {
#endif

typedef struct TF_VariableInputLockHolder TF_VariableInputLockHolder;

// Expose higher level Assignment operation for Pluggable vendors to implement
// in the plugin for Training. The API takes in the context with indices for
// the input and value tensors. It also accepts the copy callback provided by