continue
			}

			if expected != actual {
				t.Errorf("%s: server expected to receive %q, got %q for port %d", testName, expected, actual, port)
			}
		}

		for port, actual := range pf.received {
			if _, ok := expectedFromClient[port]; !ok {
				t.Errorf("%s: server unexpectedly received %q for port %d", testName, actual, port)
			}
		}
	})
}

RESULTS=/tmp/test-results"$(dirname ${binary})"
mkdir -p "${RESULTS}"
code=0

for testname in $("${binary}" -test.list "${RUN}" | grep '^Test'); do
  "${binary}" -test.run '^'"${testname}"'$' -test.count "${COUNT}" -test.v &> "${RESULTS}/${testname}"
  # shellcheck disable=SC2181
  if [[ $? != 0 ]]; then
    echo -e "--- ${red}FAIL:${clr} ${testname}. See ${RESULTS}/${testname} for full logs"
    code=1
  elif [[ "${VERBOSE}" == true ]]; then

	}
}

func TestShouldMirror(t *testing.T) {
	testCases := []struct {
		testName     string
		endpoints    *v1.Endpoints
		shouldMirror bool
	}{{
		testName: "Standard Endpoints",
		endpoints: &v1.Endpoints{
			ObjectMeta: metav1.ObjectMeta{
				Name: "test-endpoints",
			},
		},
		shouldMirror: true,
	}, {
		testName: "Endpoints with skip-mirror=true",
		endpoints: &v1.Endpoints{

```plain
# Input file for the test
.../dataset/**/<testname>.yaml

# Optional Mesh Config Input file
.../dataset/**/<testname>_meshconfig.yaml

# Required expected resources file.
.../dataset/**/<testname>_expected.json
```

Tests can be ignored by adding a .skip file

```plain
# Input file for the test
.../dataset/**/<testname>.yaml

# Optional file, indicating that the test should be skipped.

	flag.IntVar(&testInt, "testint", defaultInt, "test int flag")
	AddFlags(cmd)

	testName := "Initialize int Flag"
	if !flag.Parsed() {
		t.Errorf("%s: flag.Parsed() returns false, should be true", testName)
	}

	cmd.Flags().VisitAll(func(f *pflag.Flag) {
		if f.Name != "testint" {
			t.Errorf("%s: pflag name error. Actual %s, Expected %s", testName, f.Name, "testint")
		}
	})

	_ = cmd.Flags().Parse([]string{})

	if e, a := "pod", name; e != a {
		ex.t.Errorf("%s: pod: expected %q, got %q", ex.testName, e, a)
	}
	if e, a := "uid", uid; e != string(a) {
		ex.t.Errorf("%s: uid: expected %q, got %q", ex.testName, e, a)
	}
	if ex.exec {
		if e, a := "ls /", strings.Join(ex.command, " "); e != a {
			ex.t.Errorf("%s: command: expected %q, got %q", ex.testName, e, a)
		}
	} else {
		if len(ex.command) > 0 {

		if s == "ab" {
			return "ee"
		}
		return s
	}
	tests := []struct {
		testName string
		input    []string
		remove   string
		modifier func(s string) string
		want     []string
	}{
		{
			testName: "Nil input slice",
			input:    nil,
			remove:   "",
			modifier: nil,
			want:     nil,
		},
		{
			testName: "Slice doesn't contain the string",
			input:    []string{"a", "ab", "cdef"},

import static org.junit.Assert.assertTrue

class DefaultProjectDescriptorTest extends Specification {

    @Rule
    final TestName testName = new TestName()

    @Rule
    final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    final TestFile testDirectory = tmpDir.testDirectory

    def fileResolver = TestFiles.resolver(testDirectory)
    def descriptorRegistry = new DefaultProjectDescriptorRegistry()

			steps: []testStep{
				verifyMapInFile{stepName{"annotations"}, annotations},
			},
		},
		{
			name:  "test_name",
			files: map[string]string{"name_file_name": "metadata.name"},
			steps: []testStep{
				verifyLinesInFile{stepName{"name_file_name"}, testName},
			},
		},
		{
			name:  "test_namespace",
			files: map[string]string{"namespace_file_name": "metadata.namespace"},

        .thenComparing(PerformanceScenario::getClassName);

    private final String className;
    private final String testName;

    public PerformanceScenario(String className, String testName) {
        this.className = className;
        this.testName = testName;
    }

    public String getClassName() {
        return className;
    }

    public String getSimpleClassName() {