{filter: "postsubmit", labels: NewSet(CustomSetup), expected: false},
		{filter: "postsubmit", labels: NewSet(CustomSetup, Postsubmit), expected: true},
		{filter: "postsubmit,customsetup", labels: NewSet(Postsubmit, CustomSetup), expected: true},
		{filter: "postsubmit,customsetup", labels: NewSet(Postsubmit), expected: false},
		{filter: "+postsubmit,+customsetup", labels: NewSet(Postsubmit), expected: false},

    // expected-remark@+1 {{Cost: 1}}
    %9 = "tf.Const"() {value = dense<> : tensor<0x!tf_type.string>} : () -> tensor<0x!tf_type.string>
    // expected-remark@+1 {{Cost: 1}}
    %10 = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
    // expected-remark@+1 {{Cost: 1}}
    %11 = "tf.Const"() {value = dense<-1> : tensor<i32>} : () -> tensor<i32>
    // expected-remark@+1 {{Cost: 19}}

 */
class ToolingApiModelChecker {

    static <T> void checkModel(T actual, T expected, List<Object> specs) {
        assert (actual == null) == (expected == null)
        if (expected == null) {
            return
        }

        if (expected instanceof Collection) {
            assert actual instanceof Collection
            checkCollection(actual, expected) { actualItem, expectedItem ->

			if tc.errStr != "" {
				t.Errorf("[%s] no error seen, but expected failure: %s", tc.name, tc.errStr)
			} else if actual != tc.expected {
				t.Errorf("[%s] expected address %q, got %q", tc.name, tc.expected, actual)
			}
		}
	}
}

func TestAllIPv6(t *testing.T) {
	tests := []struct {
		name     string
		addrs    []string
		expected bool
	}{
		{
			name:     "ipv4 only",

					Number:   80,
					Protocol: string(protocol.TCP),
					Name:     "tcp",
				},
			},
			expected: false,
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			actual := IsTLSServer(tc.server)
			if actual != tc.expected {
				t.Errorf("IsTLSServer(%s) => %t, want %t",
					tc.server, actual, tc.expected)
			}
		})
	}
}

func TestIsHTTPServer(t *testing.T) {
	cases := []struct {

		if actual != nil && test.expected == nil {
			t.Errorf("Unexpected success, input: %v, expected: %v, actual: %v, err: %v", test.input, test.expected, actual, err)
		}
		if actual == nil && test.expected != nil {
			t.Errorf("Unexpected failure, input: %v, expected: %v, actual: %v, err: %v", test.input, test.expected, actual, err)
		}
		if (actual == nil && test.expected == nil) || reflect.DeepEqual(*actual, *test.expected) {
			continue
		}

			expected: true,
		},
	}

	for _, rt := range initTest {
		t.Run(rt.name, func(t *testing.T) {
			_, _, _, err := runKubeadmInit(t, rt.args)
			if (err == nil) != rt.expected {
				t.Fatalf(dedent.Dedent(`
					CmdInitToken test case %q failed with an error: %v
					command 'kubeadm init %s'
						expected: %t
						err: %t
					`),
					rt.name,
					err,
					rt.args,
					rt.expected,
					(err == nil),

	fake.SetLocalAddresses("eth0", "1.2.3.4")
	var expected, addr sets.Set[string]
	expected = sets.New("1.2.3.4")
	addr, _ = fake.GetLocalAddresses("eth0")
	if !addr.Equal(expected) {
		t.Errorf("Unexpected mismatch, expected: %v, got: %v", expected, addr)
	}
	addr, _ = fake.GetAllLocalAddresses()
	if !addr.Equal(expected) {
		t.Errorf("Unexpected mismatch, expected: %v, got: %v", expected, addr)
	}
	fake.SetLocalAddresses("lo", "127.0.0.1")

		if r.Hostname != expected {
			return fmt.Errorf("expected hostname %s, received %s", expected, r.Hostname)
		}
		return nil
	})
}

func Protocol(expected string) echo.Checker {
	return Each(func(r echoClient.Response) error {
		if r.Protocol != expected {
			return fmt.Errorf("expected protocol %s, received %s", expected, r.Protocol)
		}
		return nil
	})
}

func Alpn(expected string) echo.Checker {

			t.Errorf("Unexpected result, input: %v, expected: %v, actual: %v", testCase.input, testCase.expected, actual)
		}
	}
}

func TestParseSystemdToCgroupName(t *testing.T) {
	testCases := []struct {
		input    string
		expected CgroupName
	}{
		{
			input:    "/test",
			expected: []string{"test"},
		},
		{
			input:    "/test.slice",
			expected: []string{"test"},
		},