}

    /**
     * Converts to {@link Short}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Short}
     */
    public static Short toShort(final Object o, final String pattern) {
        if (o == null) {
            return null;
        } else if (o instanceof Short) {
            return (Short) o;

    }

    /**
     * Converts to {@link Byte}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Byte}
     */
    public static Byte toByte(final Object o, final String pattern) {
        if (o == null) {
            return null;
        } else if (o instanceof Byte) {
            return (Byte) o;

        final RegexRule regexRule = new RegexRule();
        regexRule.defaultRule = true;
        regexRule.allRequired = true;
        regexRule.addRule("url", Pattern.compile("http:.*"));
        regexRule.addRule("mimeType", Pattern.compile("text/html"));

        assertTrue(regexRule.match(getTestData1()));
        assertTrue(regexRule.match(getTestData2()));
        assertTrue(regexRule.match(getTestData3()));

        // Pattern uses Object (identity) equality, so we have to reach
        // inside to compare individual fields.
        return Objects.equals(pattern.pattern(), that.pattern.pattern())
            && pattern.flags() == that.pattern.flags();
      }
      return false;
    }

    @Override
    public String toString() {
      String patternString =

    }

    /**
     * Gets the pattern for extracting charset from meta tags.
     *
     * @return the meta charset pattern
     */
    public Pattern getMetaCharsetPattern() {
        return metaCharsetPattern;
    }

    /**
     * Sets the pattern for extracting charset from meta tags.
     *
     * @param metaCharsetPattern the meta charset pattern to set
     */

        try {
            final String pattern = getPattern(messageCode);
            if (pattern != null) {
                return MessageFormat.format(pattern, args);
            }
            return getNoPatternMessage(args);
        } catch (final Throwable ignore) {
            return getNoPatternMessage(args);
        }
    }

    /**
     * Returns the pattern string corresponding to the message code.
     *

            }

            verify(mockSession, times(10)).getConfig();
        }

        @Test
        @DisplayName("Should handle concurrent access patterns")
        void shouldHandleConcurrentAccessPatterns() throws InterruptedException {
            SmbSession mockSession = mock(SmbSession.class);
            Configuration mockConfig = mock(Configuration.class);

import japicmp.filter.ClassFilter
import javassist.CtClass

import java.util.regex.Pattern

/**
 * Matches JVM anonymous classes.
 */
class AnonymousClassesFilter implements ClassFilter {

    private static final Pattern PATTERN = Pattern.compile('.*\\$[0-9]+$')

    @Override
    boolean matches(CtClass ctClass) {
        return ctClass.name.matches(PATTERN)
    }

}

// NewRulesMap - creates new rules map with given values.
func NewRulesMap(eventNames []Name, pattern string, targetID TargetID) RulesMap {
	// If pattern is empty, add '*' wildcard to match all.
	if pattern == "" {
		pattern = "*"
	}

	rulesMap := make(RulesMap)
	rulesMap.add(eventNames, pattern, targetID)
	return rulesMap

    public String urls;

    /**
     * URL patterns to include during crawling.
     */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String includedUrls;

    /**
     * URL patterns to exclude during crawling.
     */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String excludedUrls;

    /**
     * Document URL patterns to include in search index.
     */