}
		}
	}
}

// TestNodeStatusUpdater_UpdateNodeStatusForNode calls setup
// calls UpdateNodeStatusesForNode on testnode-1
// check that asw.GetVolumesToReportAttached reports testnode-2 needs to be reported
// checks that testnode-1 status.volumesAttached is of length 1 and contains the correct volume
func TestNodeStatusUpdater_UpdateNodeStatusForNode(t *testing.T) {
	ctx := context.Background()

            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:

	testPod := st.MakePod().Name("foo").Namespace("ns").Obj()
	testNode := "foohost.kubernetes.mydomain.com"
	tests := []struct {
		name        string
		injectErr   error
		wantBinding *v1.Binding
	}{
		{
			name: "successful",
			wantBinding: &v1.Binding{
				ObjectMeta: metav1.ObjectMeta{Namespace: "ns", Name: "foo"},
				Target:     v1.ObjectReference{Kind: "Node", Name: testNode},
			},
		}, {
			name:      "binding error",

    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

    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) {

		},
	}
	for i := range tests {
		tt := &tests[i]
		t.Run(tt.name, func(t *testing.T) {
			testNode := &model.Proxy{
				Labels: map[string]string{
					"app": "foo",
				},
				Metadata: &model.NodeMetadata{},
			}

			got := BuildInboundTLS(model.MTLSStrict, testNode, networking.ListenerProtocolTCP, []string{}, tls.TlsParameters_TLSv1_2, &tt.mesh)

	valid := CNIPluginAddEvent{
		Netns:        "/var/netns/foo",
		PodName:      "pod-bingo",
		PodNamespace: "funkyns",
		IPs: []IPConfig{{
			Address: *addr,
		}},
	}

	setupLogging()
	NodeName = "testnode"
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	pod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "pod-bingo",
			Namespace: "funkyns",
		},
		Spec: corev1.PodSpec{

            XmlNode child = children.get(filteredIndex);
            if (testNode(child)) {
                filteredChildren.add(child);
            }
        }
    }

    private boolean testNode(XmlNode node) {
        if (test == null) {
            return true;
        }
        if (test instanceof NodeNameTest) {

			return
		}
		if s == '\n' {
			line++
			offs = i + 1
		}
	}
	if len(dst) != len(src) {
		t.Errorf("len(dst) = %d, len(src) = %d\nsrc = %q", len(dst), len(src), src)
	}
}

func TestNode(t *testing.T) {
	src, err := os.ReadFile(testfile)
	if err != nil {
		t.Fatal(err)
	}

	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, testfile, src, parser.ParseComments)
	if err != nil {

        0 * listener1.onDiscovered(_)
        0 * listener2.onDiscovered(_)
    }

    def node(String path, Class<?> type = String, State state = State.Discovered) {
        def node = new TestNode(path, type)
        node.setState(state)
        return node
    }

    def root() {
        return node("", Void, State.Created)
    }

    private ModelListener allAcceptingListener() {