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

        expect:
        parse(source) == transformed

        where:
        source              | transformed
        "text<p>para 2</p>" | "<p>text</p><p>para 2</p>"
        "text<h2>text</h2>" | "<p>text</p><h2>text</h2>"
    }

    def "does not add implicit <p> element for elements with inline content"() {
        expect:
        parse(source) == transformed

        where:

        then:
        format(link) == '<someLinkElement/>'
        _ * nameResolver.resolve('someName', classMetaData) >> 'org.gradle.SomeClass'
        _ * linkRenderer.link({it.name == 'org.gradle.SomeClass'}, listener) >> parse('<someLinkElement/>')
    }

    def convertsFullyQualifiedClassNameToLink() {
        when:
        def link = converter.resolve('org.gradle.SomeClass', classMetaData, listener)

        then:

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

może zawierać tylko znaki alfanumeryczne ",badAlphaNumericExtra:" i ",wrongFileSize:"Wysyłany plik jest zbyt duży (max %s)",wrongFileType:"Dozwolone są tylko pliki typu %s",groupCheckedRangeStart:"Proszę wybrać pomiędzy ",groupCheckedTooFewStart:"Proszę wybrać przynajmniej ",groupCheckedTooManyStart:"Proszę wybrać maksymalnie ",groupCheckedEnd:" element(ów)",badCreditCard:"Podany numer karty kredytowej jest nieprawidłowy",badCVV:"Podany numer CVV jest nieprawidłowy",wrongFileDim:"Nieprawidłowe wymiary...

  @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'\"")

		if info.Person == nil {
			t.Fatalf("Failed, expected not nil, got person nil")
		}
		if info.Address == nil {
			t.Fatalf("Failed, expected not nil, got address nil")
		}
		if info.Person.ID == person1.ID {
			personMatched = true
			if info.Person.Name != person1.Name {
				t.Errorf("Failed, expected %v, got %v", person1.Name, info.Person.Name)
			}
		}

    }

    public void test_parse() {
        PrunedTag[] tags = PrunedTag.parse("");
        assertEquals(0, tags.length);

        tags = PrunedTag.parse("a");
        assertEquals(1, tags.length);
        assertEquals("PrunedTag [tag=a, id=null, css=null, attrName=null, attrValue=null]", tags[0].toString());

        tags = PrunedTag.parse("a#test");
        assertEquals(1, tags.length);

        QueryParser queryParser = new QueryParser();

        Query query = queryParser.createDefaultFilterChain().parse("fess");
        assertEquals(TermQuery.class, query.getClass());
        assertEquals("_default:fess", ((TermQuery) query).getTerm().toString());

        query = queryParser.createDefaultFilterChain().parse("title:fess");
        assertEquals(TermQuery.class, query.getClass());

    assertThat(cacheControl.mustRevalidate).isFalse()
  }

  @Test
  @Throws(Exception::class)
  fun parse() {
    val header = (
      "no-cache, no-store, max-age=1, s-maxage=2, private, public, must-revalidate, " +
        "max-stale=3, min-fresh=4, only-if-cached, no-transform"
    )
    val cacheControl =
      parse(
        Headers.Builder()
          .set("Cache-Control", header)
          .build(),
      )