/**
 * Pluggable interface for compiling a regex pattern. By default this package uses the {@code
 * java.util.regex} library, but an alternate implementation can be supplied using the {@link
 * java.util.ServiceLoader} mechanism.
 */
@GwtIncompatible
interface PatternCompiler {
  /**
   * Compiles the given pattern.
   *
   * @throws IllegalArgumentException if the pattern is invalid
   */
  @RestrictedApi(

            return this.established && this.integrity;
        }
    }

    @Nested
    @DisplayName("Happy path behavior")
    class HappyPath {
        @Test
        @DisplayName("All getters return configured values and MIC roundtrips")
        void testAllMethodsHappyPath() throws Exception {
            // Arrange

    private static final List<String> ALLOWED_PLATFORMS = List.of("darwin", "linux", "windows", "mac");
    private static final Pattern VERSION_PATTERN = Pattern.compile("(\\d+)(\\.\\d+\\.\\d+)?\\+(\\d+(?:\\.\\d+)?)(@([a-f0-9]{32}))?");
    private static final Pattern LEGACY_VERSION_PATTERN = Pattern.compile("(\\d)(u\\d+)\\+(b\\d+?)(@([a-f0-9]{32}))?");

    private final String name;
    private final Configuration configuration;

/**
 * Tests for the {@link AllocInfo} interface.
 * Since {@code AllocInfo} only declares getters, the tests focus on
 * verifying that implementations honour the contract.
 */
@ExtendWith(MockitoExtension.class)
public class AllocInfoTest {

    @Mock
    AllocInfo mockAllocInfo;

    /**
     * Happy path – verifies that getters return the values supplied by the
     * implementation.
     */
    @Test

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() {

     * <p>
     * Patterns can be exact class names or use wildcards with '*' at the end.
     * For example: "com.example.*" allows all classes in the com.example package.
     * </p>
     *
     * @param allowedPatterns the patterns of classes to allow
     * @return an ObjectInputFilter configured with the specified patterns
     */

import java.util.Map;
import java.util.regex.Pattern;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

/**
 * Tests for SpnegoConstants interface.
 * Verifies constant values, modifiers, types, and structural properties.
 */
class SpnegoConstantsTest {

    // Simple OID format: numbers separated by dots (at least one dot)
    private static final Pattern OID_PATTERN = Pattern.compile("\\d+(?:\\.\\d+)+");

	}

	*ruleList = FilterRuleList(rules)
	return nil
}

func (ruleList FilterRuleList) isEmpty() bool {
	return len(ruleList.Rules) == 0
}

// Pattern - returns pattern using prefix and suffix values.
func (ruleList FilterRuleList) Pattern() string {
	var prefix string
	var suffix string

	for _, rule := range ruleList.Rules {
		switch rule.Name {
		case "prefix":
			prefix = rule.Value

import java.nio.file.attribute.BasicFileAttributes;
import java.util.regex.Pattern;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

class ComparableVersionIT {

    @Test
    void test() throws Exception {
        Files.walkFileTree(Paths.get("target"), new SimpleFileVisitor<Path>() {
            Pattern mavenArtifactJar = Pattern.compile("maven-artifact-[\\d.]+(-SNAPSHOT)?\\.jar");

)

const (
	percent    rune = '%'
	underscore rune = '_'
	runeZero   rune = 0
)

func evalSQLLike(text, pattern string, escape rune) (match bool, err error) {
	s := []rune{}
	prev := runeZero
	hasLeadingPercent := false
	patLen := len([]rune(pattern))
	for i, r := range pattern {
		if i > 0 && prev == escape {
			switch r {
			case percent, escape, underscore:
				s = append(s, r)
				prev = r