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

			if tc.updateFn != nil {
				tc.updateFn(copied)
			}
			expected := copied.DeepCopy()

			syncer.TerminatePod(copied)
			status := expectPodStatus(t, syncer, tc.pod.DeepCopy())
			if tc.expectFn != nil {
				tc.expectFn(t, status)
				return
			}
			if !reflect.DeepEqual(expected.Status, status) {
				diff := cmp.Diff(expected.Status, status)
				if len(diff) == 0 {

		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,
	}, {

		t.Fatalf("RemoveVolumeFromReportAsAttached failed. Expected: <no error> Actual: <%v>", markDesireToDetachErr)
	}
	if addErr != nil {
		t.Fatalf("AddVolumeNode failed. Expected: <no error> Actual: <%v>", addErr)
	}

	// Assert
	attachedVolumes := asw.GetAttachedVolumes()
	if len(attachedVolumes) != 1 {
		t.Fatalf("len(attachedVolumes) Expected: <1> Actual: <%v>", len(attachedVolumes))
	}

			fail = true
			t.Errorf("Case %v (%s, %s, %v) podQuotaCount mismatch: got %v, expect %v", seq, testcase.name, testcase.path, enabled, len(podQuotaMap), expectedPodQuotaCount)
		}
		if len(dirQuotaMap) != expectedDirQuotaCount {
			fail = true
			t.Errorf("Case %v (%s, %s, %v) dirQuotaCount mismatch: got %v, expect %v", seq, testcase.name, testcase.path, enabled, len(dirQuotaMap), expectedDirQuotaCount)
		}

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

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

	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> =