Ben Leggett <******@****.***> 1716316321 -0400

		input  []string
		expect bool
	}{{
		input:  nil,
		expect: false,
	}, {
		input:  []string{},
		expect: false,
	}, {
		input:  []string{"foo.go"},
		expect: false,
	}, {
		input:  []string{"foo.go", "bar.go"},
		expect: false,
	}, {
		input:  []string{"foo_test.go"},
		expect: true,
	}, {
		input:  []string{"foo.go", "foo_test.go"},
		expect: true,
	}, {

func TestStringList(t *testing.T) {
	cases := []struct {
		in          string
		expect      model.StringList
		noRoundTrip bool
	}{
		{in: `"a,b,c"`, expect: []string{"a", "b", "c"}},
		{in: `"\"a,b,c"`, expect: []string{`"a`, "b", "c"}},
		{in: `"a"`, expect: []string{"a"}},
		{in: `""`, expect: []string{}},
		{in: `"123,@#$#,abcdef"`, expect: []string{"123", "@#$#", "abcdef"}},
	}
	for _, tt := range cases {

	// for purge case we expect all resources removed
	if purge {
		if len(reStrList) != 0 {
			msg := fmt.Sprintf("resources expected to be pruned but still exist in the cluster: %s",
				strings.Join(reStrList, " "))
			scopes.Framework.Warnf(msg)
			return fmt.Errorf(msg)
		}
		return nil
	}
	// for other cases, we expect base component resources to be kept.
	if len(reStrList) != 0 {

	bar.ReportError("some error")
	expect(`❌ ` + cnbo + ` encountered an error: some error`)

	foo.ReportProgress()
	expect(`- Processing resources for ` + cnpo + `.`)

	foo.ReportFinished()
	expect(`🧠 ` + cnpo + ` installed`)

	p.SetState(StatePruning)
	expect(`- Pruning removed resources`)

	p.SetState(StateComplete)
	expect(`✅ Installation complete`)

	p.SetState(StateUninstallComplete)
	expect(`✅ Uninstall complete`)

	c := strings.SplitN(output, "\n", 2)
	if len(c) == 1 {
		t.Fatalf("expected at least one complete line in the output, got:\n%s", output)
	}
	expect, ok := strings.CutPrefix(c[0], "expect: ")
	if !ok {
		t.Fatalf("expected first line of output to start with \"expect: \", got: %q", c[0])
	}
	rest := c[1]
	if expect == "OK" && rest != "OK\n" {
		t.Fatalf("expected just 'OK' in the output, got:\n%s", rest)
	}

	goldenFile := filepath.Join("testdata", name+".golden")
	testutil.CompareContent(t, gotBytes, goldenFile)
}

func TestBuilder(t *testing.T) {
	cases := []struct {
		name         string
		expectV4     bool
		expectV6     bool
		config       func(builder *IptablesRuleBuilder)
		sharedGolden bool
	}{
		{
			"insert-single-v4",
			true,
			false,
			func(builder *IptablesRuleBuilder) {

public interface KaMultiplatformInfoProviderMixin : KaSessionMixIn {

    /**
     * Gives expect symbol for the actual one if it is available.
     *
     * @return a single expect declaration corresponds to the [KaDeclarationSymbol] on valid code or multiple expects in a case of erroneous code with multiple expects.
     **/
    public fun KaDeclarationSymbol.getExpectsForActual(): List<KaDeclarationSymbol> =

        expect:
        def result = event.convert("")
        result.response == 4
        result.newPrompt == null
    }

    def "can have negative minimum value"() {
        def event = new IntQuestionPromptEvent(123, "question?", -5, -2)

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

        where:

						Run(func(t framework.TestContext, from echo.Instance, to echo.Target) {
							for _, expected := range tt.expectations {
								expected := expected
								t.NewSubTest(expected.in).Run(func(t framework.TestContext) {
									checker := check.URL(expected.out)
									if expected.out == "400" {
										checker = check.Status(http.StatusBadRequest)
									}