static class EmptyTest {}

  static class EmptyTests {}

  static class EmptyTestSuite {}

  static class Foo {}

  @SuppressWarnings("IdentifierName") // We're testing that we ignore classes with underscores.
  static class Foo_Bar {}

  public static class PublicFoo {}

  static class FooTest {
    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}

     * <p>ASCII characters in the part are expected to be valid per RFC 1035, with underscore also
     * being allowed due to widespread practice.
     */

    String asciiChars = CharMatcher.ascii().retainFrom(part);

    if (!PART_CHAR_MATCHER.matchesAllOf(asciiChars)) {
      return false;
    }

    // No initial or final dashes or underscores.

    if (DASH_MATCHER.matches(part.charAt(0))

        this.logLevel = logLevel;
        return this;
    }

    /**
     * Sets the log suffix for this job execution.
     * The suffix is trimmed and whitespace is replaced with underscores.
     *
     * @param logSuffix the suffix to append to log file names
     * @return this ExecJob instance for method chaining
     */
    public ExecJob logSuffix(final String logSuffix) {

        value = "${123}";
        assertEquals("numeric", ResourceUtil.resolve(value));

        // Test with underscores in property names
        System.setProperty("test_var", "underscore");
        value = "${test_var}";
        assertEquals("underscore", ResourceUtil.resolve(value));

        // Clean up test properties
        System.clearProperty("var1");
        System.clearProperty("var2");

        if (options.sessionId != null) {
            options.sessionId = options.sessionId.replaceAll("-", "_");
        }

        // Check that sessionId was sanitized (hyphens replaced with underscores)
        assertEquals("test_session_123", options.sessionId);
    }

    public void test_process_withPropertiesPath() throws Exception {
        // Test that properties path is properly handled

        }
        return value;
    }

    /**
     * Replaces special characters in a string with underscores for group names.
     *
     * @param value the string to process
     * @return the string with special characters replaced by underscores
     */
    protected String replaceWithUnderscores(final String value) {
        return value.replaceAll("[/\\\\\\[\\]:;|=,+\\*?<>]", "_");

ldap.auth.validation=true
# Maximum username length for LDAP.
ldap.max.username.length=-1
# Whether to ignore NetBIOS name in LDAP.
ldap.ignore.netbios.name=true
# Whether to allow underscores in LDAP group names.
ldap.group.name.with.underscores=false
# Whether to use lowercase for LDAP permission names.
ldap.lowercase.permission.name=false
# Whether to allow empty permissions in LDAP.
ldap.allow.empty.permission=true

     */
    boolean isLdapIgnoreNetbiosName();

    /**
     * Get the value for the key 'ldap.group.name.with.underscores'. <br>
     * The value is, e.g. false <br>
     * comment: Whether to allow underscores in LDAP group names.
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */
    String getLdapGroupNameWithUnderscores();

    public Integer crudMode;

    /**
     * The name of the label type.
     */
    @Required
    @Size(max = 100)
    public String name;

    /**
     * The value of the label type (alphanumeric and underscore only).
     */
    @Required
    @Size(max = 100)
    @Pattern(regexp = "^[a-zA-Z0-9_]+$")
    public String value;

    /**
     * The paths to include for this label type.
     */

     * <p>
     * When copying between JavaBeans and {@link Map}, you can change the delimiter for property names.
     * For example, if you specify an underscore as the delimiter for JavaBeans and a period as the delimiter for {@link Map},
     * the property names for the source and destination will be as follows:
     * </p>
     * <table border="1">