MediaType.parse("text/plain; charset=UTF-8"),
            MediaType.parse("text/plain ; charset=utf-8"),
            MediaType.parse("text/plain; charset =UTF-8"),
            MediaType.parse("text/plain; charset= UTF-8"),
            MediaType.parse("text/plain; charset  =  UTF-8"),
            MediaType.parse("text/plain; charset=\tUTF-8"))

        .addEqualityGroup(parse(""), parse(""))
        .addEqualityGroup(parse("concurrencyLevel=7"), parse("concurrencyLevel=7"))
        .addEqualityGroup(parse("concurrencyLevel=15"), parse("concurrencyLevel=15"))
        .addEqualityGroup(parse("initialCapacity=7"), parse("initialCapacity=7"))
        .addEqualityGroup(parse("initialCapacity=15"), parse("initialCapacity=15"))
        .addEqualityGroup(parse("maximumSize=7"), parse("maximumSize=7"))

        .`when`(
          request()
            .withPath("/person")
            .withQueryStringParameter("name", "peter"),
        ).respond(response().withBody("Peter the person!"))

      val results =
        (1..20).map {
          executor.submit {
            val response =
              client.newCall(Request((mockServer.secureEndpoint + "/person?name=peter").toHttpUrl())).execute()

		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)
	}

    assertThat(parse("http:\\/host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:/\\host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\\\host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:///host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\//host/path"))
      .isEqualTo(parse("http://host/path"))

        try {
            // parse(String)
            Method parseMethod = KuromojiCSVUtil.class.getMethod("parse", String.class);
            assertTrue("parse should be static", java.lang.reflect.Modifier.isStatic(parseMethod.getModifiers()));
            assertTrue("parse should be public", java.lang.reflect.Modifier.isPublic(parseMethod.getModifiers()));

        try {
            sitemapsHelper.parse(in);
            fail();
        } catch (final CrawlingAccessException e) {
            // NOP
        }
    }

    public void test_parseXmlSitemaps_invalid2() {
        final byte[] bytes = "test".getBytes();
        final InputStream in = new ByteArrayInputStream(bytes);

        try {
            sitemapsHelper.parse(in);
            fail();

     */
    @Nonnull
    Model parse(@Nonnull Source source, @Nullable Map<String, ?> options) throws ModelParserException;

    /**
     * Locate and parse the model in the specified directory.
     * This is equivalent to {@code locate(dir).map(s -> parse(s, options))}.
     *
     * @param dir the directory to locate the pom for, never {@code null}

  @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