func TestIdleConnH2Crash(t *testing.T) { run(t, testIdleConnH2Crash, []testMode{http2Mode}) }
func testIdleConnH2Crash(t *testing.T, mode testMode) {
	cst := newClientServerTest(t, mode, HandlerFunc(func(w ResponseWriter, r *Request) {
		// nothing
	}))

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	sawDoErr := make(chan bool, 1)
	testDone := make(chan struct{})
	defer close(testDone)

            getSupportedNodeType() >> TestNode
        }
        def registry = new ToPlannedNodeConverterRegistry([testConverter])

        when:
        def foundConverter = registry.getConverter(new TestNode())
        then:
        foundConverter.is(testConverter)

        // verify caching works
        when:
        foundConverter = registry.getConverter(new TestNode())
        then:

        @Override
        String toString() {
            return "TestNode($name)"
        }
    }

    static class TestTaskNode extends TestNode {
        TestTaskNode(String name) {
            super(name)
        }
    }

    static class TestTransformStepNode extends TestNode {
        TestTransformStepNode(String name) {
            super(name)
        }
    }

	"k8s.io/klog/v2/ktesting"
	frameworkruntime "k8s.io/kubernetes/pkg/scheduler/framework/runtime"
	st "k8s.io/kubernetes/pkg/scheduler/testing"
)

func TestDefaultBinder(t *testing.T) {
	testPod := st.MakePod().Name("foo").Namespace("ns").Obj()
	testNode := "foohost.kubernetes.mydomain.com"
	tests := []struct {
		name        string
		injectErr   error
		wantBinding *v1.Binding
	}{
		{
			name: "successful",

    def "should have zero executed rules initially"() {
        expect:
        new TestNode(registration).getExecutedRules().size() == 0
    }

    def "should record executed rules when notify fired #fireCount time(s)"() {
        def descriptor = Mock(ModelRuleDescriptor)
        ModelNodeInternal modelNode = new TestNode(registration)
        def executionBinder = Mock(RuleBinder)
        executionBinder.isBound() >> true

        }
    }

    private static class DelegateNode extends TestNode {
        private final List<TestNode> dependencies
        private Action<Node> monitor

        DelegateNode(String displayName, List<TestNode> dependencies) {
            super(displayName)
            this.dependencies = dependencies
            for (TestNode dep in dependencies) {
                dep.addObserver {

				},
			},
		},
	}
	testPod2 := testPod1.DeepCopy()
	testPod2.UID = "2222"
	testPod2.Name = "pod2"
	testPod2.Namespace = "ns2"
	testPod3 := testPod1.DeepCopy()
	testPod3.UID = "3333"
	testPod3.Name = "pod3"
	testPod3.Namespace = "ns2"

	testKubelet.fakeKubeClient = fake.NewSimpleClientset(testPod1, testPod2, testPod3)
	kubelet.kubeClient = testKubelet.fakeKubeClient

	// Only testing HTTP/1, and our http2 server doesn't support hijacking.
	run(t, func(t *testing.T, mode testMode) {
		testHandlerPanic(t, true, mode, nil, "intentional death for testing")
	}, []testMode{http1Mode})
}

func testHandlerPanic(t *testing.T, withHijack bool, mode testMode, wrapper func(Handler) Handler, panicValue any) {
	// Direct log output to a pipe.
	//

        def model1 = converter.builder(TestModel.class).mixInTo(TestModel, ConfigMixin).build(protocolModel)

        def model2 = converter.adapt(TestModel.class, protocolModel)
        !model1.is(model2)

        def model3 = converter.builder(TestModel.class).build(protocolModel)
        model3.is(model2)

        def model4 = converter.builder(TestModel.class).mixInTo(TestModel, ConfigMixin).build(protocolModel)

    protected static class TestNode extends ModelNodeInternal {
        def links = []

        TestNode(String creationPath, Class<?> type) {
            super(null, ModelRegistrations.of(ModelPath.path(creationPath)).descriptor("test").build())
            addProjection(new UnmanagedModelProjection(ModelType.of(type)))
        }

        TestNode(ModelRegistration registration) {