/*
 * regex(3) test harness
 *
 * build:	cc -o testregex testregex.c
 * help:	testregex --man
 * note:	REG_* features are detected by #ifdef; if REG_* are enums
 *		then supply #define REG_foo REG_foo for each enum REG_foo
 *
 *	Glenn Fowler <******@****.***>
 *	AT&T Research
 *
 * PLEASE: publish your tests so everyone can benefit
 *
 * The following license covers testregex.c and all associated test data.
 *

AT&T POSIX Test Files
See textregex.c for copyright + license.

testregex.c	http://www2.research.att.com/~gsf/testregex/testregex.c
basic.dat	http://www2.research.att.com/~gsf/testregex/basic.dat
nullsubexpr.dat	http://www2.research.att.com/~gsf/testregex/nullsubexpr.dat
repetition.dat	http://www2.research.att.com/~gsf/testregex/repetition.dat

The test data has been edited to reflect RE2/Go differences:

			i = j + 1
		}
	}
	return out
}

// TestFowler runs this package's regexp API against the
// POSIX regular expression tests collected by Glenn Fowler
// at http://www2.research.att.com/~astopen/testregex/testregex.html.
func TestFowler(t *testing.T) {
	files, err := filepath.Glob("testdata/*.dat")
	if err != nil {
		t.Fatal(err)
	}
	for _, file := range files {
		t.Log(file)
		testFowler(t, file)
	}

        registerModifiedProperty("processType");
        this.processType = value;
    }

    public String getRegex() {
        checkSpecifiedProperty("regex");
        return convertEmptyToNull(regex);
    }

    public void setRegex(String value) {
        registerModifiedProperty("regex");
        this.regex = value;
    }

    public String getReplacement() {

go test -cpu=1 -run=X/Y -bench=X/Y -count=2 -v testregexp

# Test the following:

# TestX is run, twice
stdout -count=2 '^=== RUN   TestX$'
stdout -count=2 '^    x_test.go:6: LOG: X running$'

# TestX/Y is run, twice
stdout -count=2 '^=== RUN   TestX/Y$'
stdout -count=2 '^    x_test.go:8: LOG: Y running$'

# TestXX is run, twice
stdout -count=2 '^=== RUN   TestXX$'
stdout -count=2 '^    z_test.go:10: LOG: XX running'

# TestZ is not run

                "processType");
        setupEpg(_epgMap, et -> ((PathMapping) et).getRegex(), (et, vl) -> ((PathMapping) et).setRegex(DfTypeUtil.toString(vl)), "regex");
        setupEpg(_epgMap, et -> ((PathMapping) et).getReplacement(), (et, vl) -> ((PathMapping) et).setReplacement(DfTypeUtil.toString(vl)),
                "replacement");

        final String sessionId = "test";
        final List<PathMapping> pathMappingList = new ArrayList<PathMapping>();
        final PathMapping pathMapping = new PathMapping();
        pathMapping.setRegex("file:///home/");
        pathMapping.setReplacement("http://localhost/");
        pathMappingList.add(pathMapping);

        pathMappingHelper.setPathMappingList(sessionId, pathMappingList);

    }

    def testHoursZeroMinutes() {
        when:
        setTime(1, 0, 32, 0)

        then:
        timer.getElapsed() == "1 hrs 0 mins 32.0 secs"
    }

    def testReset() throws Exception {
        when:
        setTime(100)
        timer.reset()
        setTime(200)

        then:
        timer.elapsedMillis == 100
    }

    def testElapsed() throws Exception {

            });
            if (logger.isDebugEnabled()) {
                cachedPathMappingList.forEach(e -> {
                    logger.debug("path mapping: {}: {} -> {}", e.getId(), e.getRegex(), e.getReplacement());
                });
            }
            return cachedPathMappingList.size();
        } catch (final ComponentNotFoundException e) {
            if (logger.isDebugEnabled()) {

        asDocMeta().version(version);
    }

    public String process(final PathMappingHelper pathMappingHelper, final String input) {
        if (regexPattern == null) {
            regexPattern = Pattern.compile(getRegex());
        }
        final Matcher matcher = regexPattern.matcher(input);
        if (matcher.find()) {
            if (pathMapperFunc == null) {