import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SourceMetaDataVisitor extends VoidVisitorAdapter<ClassMetaDataRepository<ClassMetaData>> {
    private static final Pattern GETTER_METHOD_NAME = Pattern.compile("(get|is)(.+)");
    private static final Pattern SETTER_METHOD_NAME = Pattern.compile("set(.+)");
    private final List<ClassMetaData> allClasses = new ArrayList<ClassMetaData>();

         */
        KILL_ALL_GRADLE_PROCESSES
    }

    private static final Pattern UNIX_PID_PATTERN = Pattern.compile("([0-9]+)");
    private static final Pattern WINDOWS_PID_PATTERN = Pattern.compile("([0-9]+)\\s*$");
    private static final String MY_PID = String.valueOf(ProcessHandle.current().pid());

     *
     * @param cmdList the command list to add properties to
     * @param regex the regular expression pattern to match property names
     */
    protected void addFessCustomSystemProperties(final List<String> cmdList, final String regex) {
        if (StringUtil.isNotBlank(regex)) {
            final Pattern pattern = Pattern.compile(regex);

    )

    val excludes = listOf("**/internal/**")

    private val includePackagePatterns: List<Pattern> by lazy {
        includes.map {
            if (it.endsWith("/**")) {
                Pattern.compile(it.substring(0, it.length - 3).replace("/", "\\.") + "(\\..+)?")
            } else {
                Pattern.compile(it.substring(0, it.length - 2).replace("/", "\\.") + "\\.[^.]+")
            }
        }
    }

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * Helper class to format multiline messages to the console
 */
public class MultilineMessageHelper {

    private static final int DEFAULT_MAX_SIZE = 65;
    private static final char BOX_CHAR = '*';

    private static final Pattern S_FILTER = Pattern.compile("\\s+");

    public static String separatorLine() {

    }

    /**
     * Extracts the token value from the content using the given pattern.
     * @param tokenPattern The regex pattern.
     * @param content The content to search.
     * @return The extracted token value.
     */
    protected String getTokenValue(final String tokenPattern, final String content) {
        final Matcher matcher = Pattern.compile(tokenPattern).matcher(content);
        if (matcher.find()) {

        TimeUnit unit,
        Class<?> cls,
        Joiner joiner,
        Pattern pattern,
        UnsignedInteger ui,
        UnsignedLong ul,
        StringBuilder sb,
        Predicate<?> pred,
        Function<?, ?> func,
        Object obj) {
      delegate.foo(
          s, r, n, it, b, eq, e, in, c, ord, charset, unit, cls, joiner, pattern, ui, ul, sb, pred,
          func, obj);
    }

    @Override

        sitemapsRule.addRule("url", Pattern.compile(".*sitemap.*"));
        assertTrue(sitemapsRule.match(responseData));
        InputStream is = responseData.getResponseBody();
        assertTrue(is instanceof InputStream);
        CloseableUtil.closeQuietly(responseData);
    }

    private void assertMatchFalse(ResponseData responseData) {
        sitemapsRule.addRule("url", Pattern.compile(".*sitemap.*"));

    @Deprecated(since = "4.0.0")
    String RELEASE_VERSION = "RELEASE";

    @Deprecated(since = "4.0.0")
    String LATEST_VERSION = "LATEST";

    String SNAPSHOT_VERSION = "SNAPSHOT";

    Pattern VERSION_FILE_PATTERN = Pattern.compile("^(.*)-(\\d{8}\\.\\d{6})-(\\d+)$");

    // TODO into artifactScope handler

    String SCOPE_COMPILE = "compile";

    String SCOPE_COMPILE_PLUS_RUNTIME = "compile+runtime";

        "detail": [
            {
                "type": "string_pattern_mismatch",
                "loc": ["query", "q"],
                "msg": "String should match pattern '^fixedquery$'",
                "input": "nonregexquery",
                "ctx": {"pattern": "^fixedquery$"},
            }
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")