final VaMessenger<FessMessages> complexMessageCode =
                messages -> messages.addErrorsInvalidQueryParseError(UserMessages.GLOBAL_PROPERTY_KEY);
        final String message = "Failed to parse query: " + queryString;

        // Execute
        final InvalidQueryException exception = new InvalidQueryException(complexMessageCode, message);

        // Verify
        assertNotNull(exception);

        if (StringUtil.isNotBlank(roleName)) {
            roleNameList.add(roleName);
        }
    }

    /**
     * Parses the role set from a string.
     * @param value The string to parse.
     * @param encrypted Whether the string is encrypted.
     * @param roleSet The set of roles.
     */

		t.Fatalf("failed to parse user with map, got error %v", err)
	}

	if field := user.FieldsByName["Attrs"]; field.DataType != "Map(String,String)" {
		t.Errorf("failed to parse user field Attrs")
	}
}

func TestParseSchemaWithPointerFields(t *testing.T) {
	user, err := schema.Parse(&User{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {
		t.Fatalf("failed to parse pointer user, got error %v", err)
	}

  @Test fun testIllegalCharsetName() {
    val mediaType = parse("text/plain; charset=\"!@#$%^&*()\"")
    assertNull(mediaType.charsetName())
  }

  @Test fun testUnsupportedCharset() {
    val mediaType = parse("text/plain; charset=utf-wtf")
    assertNull(mediaType.charsetName())
  }

  @Test fun testCharsetNameIsDoubleQuotedAndSingleQuoted() {
    val mediaType = parse("text/plain;charset=\"'utf-8'\"")

pkg text/template/parse, const NodeBreak = 21
pkg text/template/parse, const NodeBreak NodeType
pkg text/template/parse, const NodeContinue = 22
pkg text/template/parse, const NodeContinue NodeType
pkg text/template/parse, method (*BreakNode) Copy() Node
pkg text/template/parse, method (*BreakNode) String() string
pkg text/template/parse, method (*ContinueNode) Copy() Node

        } catch (final Exception e) {
            logger.warn("Failed to serialize JSON.", e);
            return "{}";
        }
    }

    /**
     * Parses a JSON string into a map.
     *
     * @param json the JSON string to parse.
     * @return the parsed map, or an empty map on failure.
     */
    protected Map<String, Object> parseJson(final String json) {
        try {

  public static byte parseUnsignedByte(String string, int radix) {
    int parse = parseInt(checkNotNull(string), radix);
    // We need to throw a NumberFormatException, so we have to duplicate checkedCast. =(
    if (parse >> Byte.SIZE == 0) {
      return (byte) parse;
    } else {
      throw new NumberFormatException("out of range: " + parse);
    }
  }

  /**

import kotlin.test.assertFailsWith
import okhttp3.Protocol
import okhttp3.internal.http.StatusLine.Companion.parse
import org.junit.jupiter.api.Test

class StatusLineTest {
  @Test
  fun parse() {
    val message = "Temporary Redirect"
    val version = 1
    val code = 200
    val statusLine = parse("HTTP/1.$version $code $message")
    assertThat(statusLine.message).isEqualTo(message)

    val mediaType = parse("text/plain;a=\";charset=utf-8;b=\"")
    assertNull(mediaType.charsetName())
  }

  @Test fun testSingleQuotesAreNotSpecial() {
    val mediaType = parse("text/plain;a=';charset=utf-8;b='")
    assertEquals("UTF-8", mediaType.charsetName())
  }

  @Test fun testParseWithSpecialCharacters() {

        PrunedTag[] tags = PrunedTag.parse("");
        assertEquals(0, tags.length);

        // Test null
        tags = PrunedTag.parse(null);
        assertEquals(0, tags.length);

        // Test whitespace only
        tags = PrunedTag.parse("   ");
        assertEquals(0, tags.length);

        // Test commas only
        tags = PrunedTag.parse(",,,");
        assertEquals(0, tags.length);