charactertranslationtest.java

html解析包 可以很方便的解析html 纯java 实现

    public void testInitialNumericCharacterReferenceWithoutSemi ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#247 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi1 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#xf7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi2 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#xF7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi3 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#x0f7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi4 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#x0F7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi5 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#Xf7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi6 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#XF7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi7 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#X0f7 is the division sign."));
    }

    public void testInitialHexNumericCharacterReferenceWithoutSemi8 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at start of string doesn't work",
            "\u00f7 is the division sign.",
            Translate.decode ("&#X0F7 is the division sign."));
    }

    public void testFinalCharacterEntityReference ()
    {
        assertEquals (
            "character entity reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalNumericCharacterReference ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference1 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference2 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference3 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference4 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference5 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference6 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference7 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalHexNumericCharacterReference8 ()
    {
        assertEquals (
            "numeric character reference at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is ÷"));
    }

    public void testFinalCharacterEntityReferenceWithoutSemi ()
    {
        assertEquals (
            "character entity reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &divide"));
    }

    public void testFinalNumericCharacterReferenceWithoutSemi1 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#247"));
    }

    public void testFinalNumericCharacterReferenceWithoutSemi2 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#0247"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi1 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#xf7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi2 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#xF7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi3 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#x0f7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi4 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#x0F7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi5 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#Xf7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi6 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#XF7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi7 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#X0f7"));
    }

    public void testFinalHexNumericCharacterReferenceWithoutSemi8 ()
    {
        assertEquals (
            "numeric character reference without a semicolon at end of string doesn't work",
            "The division sign (\u00f7) is \u00f7",
            Translate.decode ("The division sign (\u00f7) is &#X0F7"));
    }

    public void testReferencesInString ()
    {
        assertEquals (
            "character references within a string don't work",
            "Thus, the character entity reference \u00f7 is a more convenient form than \u00f7 for obtaining the division sign (\u00f7)",
            Translate.decode ("Thus, the character entity reference ÷ is a more convenient form than ÷ for obtaining the division sign (\u00f7)"));
    }

    public void testBogusCharacterEntityReference1 ()
    {
        assertEquals (
            "bogus character entity reference doesn't work",
            "The character entity reference &divode; is bogus",
            Translate.decode ("The character entity reference &divode; is bogus"));
    }

    public void testBogusCharacterEntityReference2 ()
    {
        assertEquals (
            "bogus character entity reference doesn't work",
            "The character entity reference &(divide) is bogus",
            Translate.decode ("The character entity reference &(divide) is bogus"));
    }

    public void testBogusNumericCharacterReference ()
    {
        assertEquals (
            "bogus numeric character reference doesn't work",
            "The numeric character reference &#BF7; is bogus",
            Translate.decode ("The numeric character reference &#BF7; is bogus"));
    }

    public void testBogusHexNumericCharacterReference ()
    {
        assertEquals (
            "bogus numeric character reference doesn't work",
            "The numeric character reference &#xKJ7; is bogus",
            Translate.decode ("The numeric character reference &#xKJ7; is bogus"));
    }

    public void testPoorlyTerminatedCharacterEntityReference1 ()
    {
        assertEquals (
            "poorly terminated character entity reference doesn't work",
            "The character entity reference \u00f7d should be decoded",
            Translate.decode ("The character entity reference &divided should be decoded"));
    }

    public void testPoorlyTerminatedCharacterEntityReference2 ()
    {
        assertEquals (
            "poorly terminated character entity reference doesn't work",
            "The character entity reference \u00f7<br> should be decoded",
            Translate.decode ("The character entity reference &divide<br> should be decoded"));
    }

    public void testPoorlyTerminatedNumericCharacterReference1 ()
    {
        assertEquals (
            "poorly terminated numeric character reference doesn't work",
            "The numeric character reference \u00f7pop should be decoded",
            Translate.decode ("The numeric character reference &#xf7pop should be decoded"));
    }

    public void testPoorlyTerminatedNumericCharacterReference2 ()
    {
        assertEquals (
            "poorly terminated numeric character reference doesn't work",
            "The numeric character reference \u00f7<br> should be decoded",
            Translate.decode ("The numeric character reference &#xf7<br> should be decoded"));
    }

    public void testPoorlyTerminatedNumericCharacterReference3 ()
    {
        assertEquals (
            "poorly terminated numeric character reference doesn't work",
            "The numeric character reference \u00f7xpert should be decoded",
            Translate.decode ("The numeric character reference &#xf7xpert should be decoded"));
    }

    public void testEncode ()
    {
        assertEquals (
            "encode doesn't work",
            "Character entity reference: &divide;, another: &nbsp;, numeric character reference: &#9831;.",
            Translate.encode ("Character entity reference: \u00f7, another: \u00a0, numeric character reference: \u2667."));
    }

    public void testEncodeLink ()
    {
        assertEquals (
            "encode link doesn't work",
            "&lt;a href=&quot;http://www.w3.org/TR/REC-html40/sgml/entities.html&quot;&gt;http://www.w3.org/TR/REC-html40/sgml/entities.html&lt;/a&gt;",
            Translate.encode ("<a href=\"http://www.w3.org/TR/REC-html40/sgml/entities.html\">http://www.w3.org/TR/REC-html40/sgml/entities.html</a>"));
    }

    public byte[] encodedecode (byte[] bytes)
        throws
            IOException
    {
        InputStream in;
        ByteArrayOutputStream out;
        byte[] data;

        // encode
        in = new ByteArrayInputStream (bytes);
        out = new ByteArrayOutputStream ();
        Translate.encode (in, new PrintStream (out, false, "ISO-8859-1"));
        in.close ();
        out.close ();
        data = out.toByteArray ();

        // decode
        in = new ByteArrayInputStream (data);
        out = new ByteArrayOutputStream ();
        Translate.decode (in, new PrintStream (out, false, "ISO-8859-1"));
        in.close ();
        out.close ();
        data = out.toByteArray ();

        return (data);