*/
    default TestClassExecutionResult assertTestOutcomes(TestOutcome status, String... testNames) {
        if (status == TestOutcome.SKIPPED) {
            return assertTestsSkipped(testNames);
        }
        for (String testName : testNames) {
            switch (status) {
                case PASSED:
                    assertTestPassed(testName);
                    break;
                case FAILED:

		}
	}
	return &context{
		testNames: make(map[string]struct{}),
		filter:    filter,
	}, nil
}

func (ctx *context) register(testName string) (skip bool, err error) {
	if _, ok := ctx.testNames[testName]; ok {
		return true, fmt.Errorf("duplicate test %s found", testName)
	}
	if ctx.filter != nil {
		return !ctx.filter.MatchString(testName), nil
	}
	return false, nil
}

        this
    }

    private def findConfigMethod(String testName) {
        def testMethods = findConfigMethods()
        if (!testMethods.containsKey(testName)) {
            throw new AssertionError("Could not find configuration method ${testClass}.${testName}. Found ${testMethods.keySet()}")
        }
        testMethods[testName]
    }

    private def findConfigMethods() {
        Map testMethods = [:]

        assert testName == artifact.name
        assert testType == artifact.type
        assert testExt == artifact.extension
        assert testFile == artifact.file
        if (shouldHaveClassifier) {
            assert testClassifier == artifact.classifier
        }
    }

      level: \$p.level,
      reason: \$p.reason,
      passing: map(select(.policy.fail | not)) | length,
      failing: map(select(.policy.fail)) | length,
      testnames: map(select(.policy.fail) | .testname),
    }
  })
  # add a meta policy based on whether any policy failed
  + {
    all_policies: \$results | {
      level: "WARN",
      reason: "should pass all policies",

	}, nil
}

func TestSupports(t *testing.T) {
	tests := []struct {
		testName       string
		featureName    string
		expectedResult bool
	}{
		{
			testName:    "Disabled - with unknown feature",
			featureName: "some unknown feature",
		},
		{
			testName:    "Disabled - with empty feature",
			featureName: "",
		},
		{
			testName:       "Disabled - default",
			featureName:    storage.RequestWatchProgress,

		if test.admit && err != nil {
			t.Errorf("Test: %s, expected no error but got: %s", test.testName, err)
		} else if !test.admit && err == nil {
			t.Errorf("Test: %s, expected an error", test.testName)
		}
		if test.admit && !labels.Equals(test.mergedNodeSelector, labels.Set(pod.Spec.NodeSelector)) {
			t.Errorf("Test: %s, expected: %s but got: %s", test.testName, test.mergedNodeSelector, pod.Spec.NodeSelector)
		}

				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

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