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

        classes.add(cls);
      }
    }
    return classes;
  }

  private static boolean hasTest(Class<?> testClass, Iterable<String> testNames) {
    for (String testName : testNames) {
      try {
        testClass.getMethod(testName);
        return true;
      } catch (NoSuchMethodException e) {
        continue;
      }
    }
    return false;
  }

            useDefaultListeners == source.useDefaultListeners
            threadPoolFactoryClass == source.threadPoolFactoryClass
            suiteName == source.suiteName
            testName == source.testName
            suiteXmlFiles == source.suiteXmlFiles
            preserveOrder == source.preserveOrder
            groupByInstances == source.groupByInstances
        }
    }

	} else if strings.HasSuffix(name, ":racebench") && heading != "Running benchmarks briefly." {
		panic("racebench variant is reserved exclusively for registerRaceBenchTest")
	}
	if t.testNames == nil {
		t.testNames = make(map[string]bool)
	}
	t.testNames[name] = true
	t.tests = append(t.tests, distTest{
		name:    name,
		heading: heading,
		fn:      fn,
	})
}

type registerTestOpt interface {

	if err != nil {
		t.Fatalf("failed to glob for tests: %s", err)
	}
	var testedUserRegions bool
	for _, p := range traces {
		p := p
		testName, err := filepath.Rel("./internal/oldtrace/testdata", p)
		if err != nil {
			t.Fatalf("failed to relativize testdata path: %s", err)
		}
		t.Run(testName, func(t *testing.T) {
			f, err := os.Open(p)
			if err != nil {
				t.Fatalf("failed to open test %q: %s", p, err)
			}
			defer f.Close()

        classes.add(cls);
      }
    }
    return classes;
  }

  private static boolean hasTest(Class<?> testClass, Iterable<String> testNames) {
    for (String testName : testNames) {
      try {
        testClass.getMethod(testName);
        return true;
      } catch (NoSuchMethodException e) {
        continue;
      }
    }
    return false;
  }

        expect:
        formatter.format(testDescriptor, [exception]) == """\
    java.lang.Exception: ouch
        at ClassName.testName(MyTest.java:22)

        Caused by:
        java.lang.RuntimeException: oops
            at ClassName.testName(MyTest.java:22)
"""
    }

    def "formats PlaceholderException correctly"() {
        testLogging.getShowCauses() >> true

	if err != nil {
		t.Fatalf("failed to glob for tests: %v", err)
	}
	for _, testPath := range matches {
		testPath := testPath
		testName, err := filepath.Rel("./testdata", testPath)
		if err != nil {
			t.Fatalf("failed to relativize testdata path: %v", err)
		}
		t.Run(testName, func(t *testing.T) {
			tr, exp, err := testtrace.ParseFile(testPath)
			if err != nil {

        fails(ENABLE_CLI_OPT, LOG_REPORT_LINK_AS_WARNING, *tasks)
    }

    protected void assertTestsExecuted(String testClass, String... testNames) {
        new DefaultTestExecutionResult(testDirectory)
            .testClass(testClass)
            .assertTestsExecuted(testNames)
    }

    protected static String removeVfsLogOutput(String normalizedOutput) {
        normalizedOutput

     */
    @Internal
    public String getTestName() {
        return testName;
    }

    public void setTestName(String testName) {
        this.testName = testName;
    }

    /**
     * The suiteXmlFiles to use for running TestNG.
     *
     * Note: The suiteXmlFiles can be used in conjunction with the suiteXmlBuilder.