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:

				ValueMatchers: matchers,
			},
		},
	}
}

// StringMatcherRegex creates a regex string matcher for regex.
func StringMatcherRegex(regex string) *matcher.StringMatcher {
	return &matcher.StringMatcher{
		MatchPattern: &matcher.StringMatcher_SafeRegex{
			SafeRegex: &matcher.RegexMatcher{
				Regex: regex,
			},
		},
	}
}

// StringMatcherPrefix create a string matcher for prefix matching.

		log.Fatalf("Must specify restricted regex pattern")
	}
	depsPattern, err := regexp.Compile(*restrict)
	if err != nil {
		log.Fatalf("Error compiling restricted dependencies regex: %v", err)
	}
	var excludePattern *regexp.Regexp
	if *exclude != "" {
		excludePattern, err = regexp.Compile(*exclude)
		if err != nil {
			log.Fatalf("Error compiling excluded package regex: %v", err)
		}
	}
	b, err := os.ReadFile(args[0])

  virtual ~DeathTestFactory() { }
  virtual bool Create(const char* statement, const RE* regex,
                      const char* file, int line, DeathTest** test) = 0;
};

// A concrete DeathTestFactory implementation for normal use.
class DefaultDeathTestFactory : public DeathTestFactory {
 public:
  virtual bool Create(const char* statement, const RE* regex,
                      const char* file, int line, DeathTest** test);
};

        }

        public MavenFieldValidator validMavenIdentifier() {
            notEmpty();
            if (!value.matches(ID_REGEX)) {
                throw failure(String.format("%s (%s) is not a valid Maven identifier (%s).", name, value, ID_REGEX));
            }
            return this;
        }

        public MavenFieldValidator matches(String valueFromPomFile) {

	"uuid",         // an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$
	"uuid3",        // an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$
	"uuid4",        // an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$

        factory.init();
    }

    @Override
    public void addClient(final String regex, final CrawlerClient client) {
        factory.addClient(regex, client);
    }

    @Override
    public void addClient(final String regex, final CrawlerClient client, final int pos) {
        factory.addClient(regex, client, pos);
    }

    @Override
    public int hashCode() {
        return factory.hashCode();

		},
		{
			name: "@request.auth.claims.regex",
			in:   &networking.StringMatch{MatchType: &networking.StringMatch_Regex{Regex: ".+?\\..+?\\..+?"}},
			want: authz.MetadataMatcherForJWTClaims([]string{"regex"}, authzmatcher.StringMatcherRegex(".+?\\..+?\\..+?"), false),
		},
		{
			name: "@request.auth.claims[key1",

        }
    }

    public synchronized void register(final String regex, final String componentName) {
        clientMap.put(regex, componentName);
        clientFactoryList.forEach(f -> load(f, regex, componentName));
    }

    protected void load(final CrawlerClientFactory crawlerClientFactory, final String regex, final String componentName) {
        if (logger.isDebugEnabled()) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.es.config.exentity;

import java.util.function.BiFunction;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.es.config.bsentity.BsPathMapping;