xref: /libcore/luni/src/test/java/libcore/java/net/UrlEncodingTest.java

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package libcore.java.net;

import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import junit.framework.TestCase;

public final class UrlEncodingTest extends TestCase {

    public void testUriRetainsOriginalEncoding() throws Exception {
        assertEquals("%61", new URI("http://foo#%61").getRawFragment());
    }

    /**
     * URLDecoder and URI disagree on what '+' should decode to.
     */
    public void testDecodingPlus() throws Exception {
        assertEquals("a b", URLDecoder.decode("a+b"));
        assertEquals("a b", URLDecoder.decode("a+b", "UTF-8"));
        assertEquals("a+b", new URI("http://foo#a+b").getFragment());
    }

    public void testEncodingPlus() throws Exception {
        assertEquals("a%2Bb", URLEncoder.encode("a+b"));
        assertEquals("a%2Bb", URLEncoder.encode("a+b", "UTF-8"));
        assertEquals("a+b", new URI("http", "foo", "/", "a+b").getRawFragment());
    }

    public void testDecodingSpace() throws Exception {
        assertEquals("a b", URLDecoder.decode("a b"));
        assertEquals("a b", URLDecoder.decode("a b", "UTF-8"));
        try {
            new URI("http://foo#a b");
            fail();
        } catch (URISyntaxException expected) {
        }
    }

    public void testEncodingSpace() throws Exception {
        assertEquals("a+b", URLEncoder.encode("a b"));
        assertEquals("a+b", URLEncoder.encode("a b", "UTF-8"));
        assertEquals("a%20b", new URI("http", "foo", "/", "a b").getRawFragment());
    }

    public void testUriDecodingPartial() throws Exception {
        try {
            new URI("http://foo#%");
            fail();
        } catch (URISyntaxException expected) {
        }
        try {
            new URI("http://foo#%0");
            fail();
        } catch (URISyntaxException expected) {
        }
    }

    public void testUrlDecoderDecodingPartial() throws Exception {
        try {
            URLDecoder.decode("%");
            fail();
        } catch (IllegalArgumentException expected) {
        }
        try {
            URLDecoder.decode("%0");
            fail();
        } catch (IllegalArgumentException expected) {
        }
    }

    public void testUriDecodingInvalid() {
        try {
            new URI("http://foo#%0g");
            fail();
        } catch (URISyntaxException expected) {
        }
    }

    public void testUrlDecoderDecodingInvalid() {
        try {
            URLDecoder.decode("%0g");
            fail();
        } catch (IllegalArgumentException expected) {
        }
    }

    public void testUrlDecoderFailsOnNullCharset() throws Exception {
        try {
            URLDecoder.decode("ab", null);
            fail();
        } catch (IllegalCharsetNameException expected) {
        } catch (NullPointerException expected) {
        }
    }

    public void testUrlDecoderFailsOnEmptyCharset() {
        try {
            URLDecoder.decode("ab", "");
            fail();
        } catch (IllegalCharsetNameException expected) {
        } catch (UnsupportedEncodingException expected) {
        }
    }

    public void testUrlEncoderFailsOnNullCharset() throws Exception {
        try {
            URLEncoder.encode("ab", null);
            fail();
        } catch (IllegalCharsetNameException expected) {
        } catch (NullPointerException expected) {
        }
    }

    public void testUrlEncoderFailsOnEmptyCharset() {
        try {
            URLEncoder.encode("ab", "");
            fail();
        } catch (IllegalCharsetNameException expected) {
        } catch (UnsupportedEncodingException expected) {
        }
    }

    /**
     * The RI looks up the charset lazily; Android looks it up eagerly. Either
     * behavior is acceptable.
     */
    public void testUrlDecoderIgnoresUnnecessaryCharset() throws Exception {
        try {
            assertEquals("ab", URLDecoder.decode("ab", "no-such-charset"));
            // no fail()
        } catch (UnsupportedCharsetException expected) {
        }
    }

    public void testUrlEncoderFailsOnInvalidCharset() throws Exception {
        try {
            URLEncoder.encode("ab", "no-such-charset");
            fail();
        } catch (UnsupportedCharsetException expected) {
        } catch (UnsupportedEncodingException expected) {
        }
    }

    public void testDecoding() throws Exception {
        assertDecoded("a\u0000b", "a%00b");
        assertDecoded("a b", "a%20b");
        assertDecoded("a+b", "a%2bb");
        assertDecoded("a%b", "a%25b");
        assertDecoded("a\u007fb", "a%7fb");
    }

    public void testEncoding() throws Exception {
        assertEncoded("a%25b", "a%b");
        assertEncoded("a%7Fb", "a\u007fb");
    }

    public void testDecodingLiterals() throws Exception {
        assertDecoded("\ud842\udf9f", "\ud842\udf9f");
    }

    public void testDecodingBrokenUtf8SequenceYieldsReplacementCharacter() throws Exception {
        assertDecoded("a\ufffdb", "a%ffb");
    }

    public void testDecodingUtf8Octets() throws Exception {
        assertDecoded("\u20AC", "%e2%82%ac");
        assertDecoded("\ud842\udf9f", "%f0%a0%ae%9f");
    }

    public void testDecodingNonUsDigits() throws Exception {
        try {
            new URI("http://foo#" + "%\u0664\u0661");
            fail();
        } catch (URISyntaxException expected) {
        }
        try {
            URLDecoder.decode("%\u0664\u0661");
            fail(); // RI fails this test returning "A"
        } catch (IllegalArgumentException expected) {
        }
    }

    /**
     * Android's URLEncoder.encode() failed for surrogate pairs, encoding them
     * as two replacement characters ("??"). http://b/3436051
     */
    public void testUrlEncoderEncodesNonPrintableNonAsciiCharacters() throws Exception {
        assertEquals("%00", URLEncoder.encode("\u0000", "UTF-8"));
        assertEquals("%00", URLEncoder.encode("\u0000"));
        assertEquals("%E2%82%AC", URLEncoder.encode("\u20AC", "UTF-8"));
        assertEquals("%E2%82%AC", URLEncoder.encode("\u20AC"));
        assertEquals("%F0%A0%AE%9F", URLEncoder.encode("\ud842\udf9f", "UTF-8"));
        assertEquals("%F0%A0%AE%9F", URLEncoder.encode("\ud842\udf9f"));
    }

    public void testUriDoesNotEncodeNonPrintableNonAsciiCharacters() throws Exception {
        assertEquals("\u20AC", new URI("http", "foo", "/", "\u20AC").getRawFragment());
        assertEquals("\ud842\udf9f", new URI("http", "foo", "/", "\ud842\udf9f").getRawFragment());
    }

    public void testUriEncodesControlCharacters() throws Exception {
        assertEquals("%01", new URI("http", "foo", "/", "\u0001").getRawFragment());

        // The RI fails this, encoding \u0001 but not \u0000
        assertEquals("%00", new URI("http", "foo", "/", "\u0000").getRawFragment());
    }

    public void testEncodeAndDecode() throws Exception {
        assertRoundTrip("http://jcltest.apache.org/test?hl=en&q=te st",
                "http%3A%2F%2Fjcltest.apache.org%2Ftest%3Fhl%3Den%26q%3Dte+st");
        assertRoundTrip ("file://a b/c/d.e-f*g_ l",
                "file%3A%2F%2Fa+b%2Fc%2Fd.e-f*g_+l");
        assertRoundTrip("jar:file://a.jar !/b.c/\u1052",
                "jar%3Afile%3A%2F%2Fa.jar+%21%2Fb.c%2F%E1%81%92");
        assertRoundTrip("ftp://test:pwd@localhost:2121/%D0%9C",
                "ftp%3A%2F%2Ftest%3Apwd%40localhost%3A2121%2F%25D0%259C");
    }

    /**
     * Asserts that {@code original} decodes to {@code decoded} using both URI
     * and UrlDecoder.
     */
    private void assertDecoded(String decoded, String original) throws Exception {
        assertEquals(decoded, new URI("http://foo#" + original).getFragment());
        assertEquals(decoded, URLDecoder.decode(original));
        assertEquals(decoded, URLDecoder.decode(original, "UTF-8"));
    }

    /**
     * Asserts that {@code original} encodes to {@code encoded} using both URI
     * and URLEncoder.
     */
    private void assertEncoded(String encoded, String original) throws Exception {
        assertEquals(encoded, URLEncoder.encode(original, "UTF-8"));
        assertEquals(encoded, URLEncoder.encode(original));
        assertEquals(encoded, new URI("http", "foo", "/", original).getRawFragment());
    }

    private void assertRoundTrip(String original, String encoded) throws Exception {
        assertEquals(encoded, URLEncoder.encode(original, "UTF-8"));
        assertEquals(original, URLDecoder.decode(encoded, "UTF-8"));
    }
}