val mainFiles = mainFiles()
    return mainFiles.map {
      val suffix = it.path.replace("${prefix}samples/guide/src/main/java/", "")
      suffix.replace("(.*)\\.java".toRegex()) { mr ->
        mr.groupValues[1].replace('/', '.')
      }.replace("(.*)\\.kt".toRegex()) { mr ->
        mr.groupValues[1].replace('/', '.') + "Kt"
      }
    }.sorted()
  }
}

@Disabled("Don't run by default")
@Tag("Slow")
class AllMainsTest {

        "regex": "^mongo\\.(.+?)\\.(collection|cmd|cx_|op_|delays_|decoding_)(.*?)$"
      },
      {
        "regex": "(cache\\.(.+?)\\.)",
        "tag_name": "cache"
      },
      {
        "regex": "(component\\.(.+?)\\.)",
        "tag_name": "component"
      },
      {
        "regex": "(tag\\.(.+?);\\.)",
        "tag_name": "tag"
      },
      {
        "regex": "(wasm_filter\\.(.+?)\\.)",

        "regex": "^mongo\\.(.+?)\\.(collection|cmd|cx_|op_|delays_|decoding_)(.*?)$"
      },
      {
        "regex": "(cache\\.(.+?)\\.)",
        "tag_name": "cache"
      },
      {
        "regex": "(component\\.(.+?)\\.)",
        "tag_name": "component"
      },
      {
        "regex": "(tag\\.(.+?);\\.)",
        "tag_name": "tag"
      },
      {
        "regex": "(wasm_filter\\.(.+?)\\.)",

		{name: "regex without headers match ?", route: &networking.HTTPRoute{
			Redirect: &networking.HTTPRedirect{
				Uri:       "/",
				Authority: "foo.biz",
			},
			Match: []*networking.HTTPMatchRequest{{
				WithoutHeaders: map[string]*networking.StringMatch{
					"header": {
						MatchType: &networking.StringMatch_Regex{Regex: "?"},
					},
				},
			}},
		}, valid: false},

        "regex": "^mongo\\.(.+?)\\.(collection|cmd|cx_|op_|delays_|decoding_)(.*?)$"
      },
      {
        "regex": "(cache\\.(.+?)\\.)",
        "tag_name": "cache"
      },
      {
        "regex": "(component\\.(.+?)\\.)",
        "tag_name": "component"
      },
      {
        "regex": "(tag\\.(.+?);\\.)",
        "tag_name": "tag"
      },
      {
        "regex": "(wasm_filter\\.(.+?)\\.)",

        "regex": "^mongo\\.(.+?)\\.(collection|cmd|cx_|op_|delays_|decoding_)(.*?)$"
      },
      {
        "regex": "(cache\\.(.+?)\\.)",
        "tag_name": "cache"
      },
      {
        "regex": "(component\\.(.+?)\\.)",
        "tag_name": "component"
      },
      {
        "regex": "(tag\\.(.+?);\\.)",
        "tag_name": "tag"
      },
      {
        "regex": "(wasm_filter\\.(.+?)\\.)",

// HostMatcherWithRegex creates a host matcher for a host using regex for proxies before 1.11.
func HostMatcherWithRegex(k, v string) *routepb.HeaderMatcher {
	var regex string
	if v == "*" {
		return &routepb.HeaderMatcher{
			Name: k,
			HeaderMatchSpecifier: &routepb.HeaderMatcher_PresentMatch{
				PresentMatch: true,
			},
		}
	} else if strings.HasPrefix(v, "*") {
		regex = `.*` + regexp.QuoteMeta(v[1:])

        this.processType = value;
    }

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

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

    public String getReplacement() {
        checkSpecifiedProperty("replacement");

                                <la:form action="/admin/pathmap/">
                                    <div class="form-group row">
                                        <label for="regex" class="col-sm-2 text-sm-right col-form-label"><la:message
                                                key="labels.regex"/></label>

        when:
        descriptor.includeGroupByRegex(null)

        then:
        IllegalArgumentException ex = thrown()
        ex.message == "Group regex cannot be null"

        when:
        descriptor.includeModuleByRegex("foo", null)

        then:
        ex = thrown()
        ex.message == "Module name regex cannot be null"

        when: