ParseUtil_4922813.java

/*
 * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* @test
   @bug 4922813
   @summary Check the new impl of encodePath will not cause regression
   @key randomness
 */

import java.util.BitSet;
import java.io.File;
import java.util.Random;
import sun.net.www.ParseUtil;

public class ParseUtil_4922813 {
    public static void main(String[] argv) throws Exception {

        int num = 400;
        while (num-- >= 0) {
            String source = getTestSource();
            String ec = sun.net.www.ParseUtil.encodePath(source);
            String v117 = ParseUtil_V117.encodePath(source);
            if (!ec.equals(v117)) {
                throw new RuntimeException("Test Failed for : \n"
                                           + "   source  =<"
                                           + getUnicodeString(source)
                                           + ">");
            }

        }
    }

    static int maxCharCount = 200;
    static int maxCodePoint = 0x10ffff;
    static Random random;
    static String getTestSource() {
        if (random == null) {
            long seed = System.currentTimeMillis();
            random = new Random(seed);
        }
        String source = "";
        int i = 0;
        int count = random.nextInt(maxCharCount) + 1;
        while (i < count) {
            int codepoint = random.nextInt(127);
            source = source + String.valueOf((char)codepoint);

            codepoint = random.nextInt(0x7ff);
            source = source + String.valueOf((char)codepoint);

            codepoint = random.nextInt(maxCodePoint);
            source = source + new String(Character.toChars(codepoint));

            i += 3;
        }
        return source;
    }

    static String getUnicodeString(String s){
        String unicodeString = "";
        for(int j=0; j< s.length(); j++){
             unicodeString += "0x"+ Integer.toString(s.charAt(j), 16);
        }
        return unicodeString;
    }
}
class ParseUtil_V117 {
    static BitSet encodedInPath;
    static {
        encodedInPath = new BitSet(256);

        // Set the bits corresponding to characters that are encoded in the
        // path component of a URI.

        // These characters are reserved in the path segment as described in
        // RFC2396 section 3.3.
        encodedInPath.set('=');
        encodedInPath.set(';');
        encodedInPath.set('?');
        encodedInPath.set('/');

        // These characters are defined as excluded in RFC2396 section 2.4.3
        // and must be escaped if they occur in the data part of a URI.
        encodedInPath.set('#');
        encodedInPath.set(' ');
        encodedInPath.set('<');
        encodedInPath.set('>');
        encodedInPath.set('%');
        encodedInPath.set('"');
        encodedInPath.set('{');
        encodedInPath.set('}');
        encodedInPath.set('|');
        encodedInPath.set('\\');
        encodedInPath.set('^');
        encodedInPath.set('[');
        encodedInPath.set(']');
        encodedInPath.set('`');

        // US ASCII control characters 00-1F and 7F.
        for (int i=0; i<32; i++)
            encodedInPath.set(i);
        encodedInPath.set(127);
    }
    /**
     * Constructs an encoded version of the specified path string suitable
     * for use in the construction of a URL.
     *
     * A path separator is replaced by a forward slash. The string is UTF8
     * encoded. The % escape sequence is used for characters that are above
     * 0x7F or those defined in RFC2396 as reserved or excluded in the path
     * component of a URL.
     */
    public static String encodePath(String path) {
        StringBuffer sb = new StringBuffer();
        int n = path.length();
        for (int i=0; i<n; i++) {
            char c = path.charAt(i);
            if (c == File.separatorChar)
                sb.append('/');
            else {
                if (c <= 0x007F) {
                    if (encodedInPath.get(c))
                        escape(sb, c);
                    else
                        sb.append(c);
                } else if (c > 0x07FF) {
                    escape(sb, (char)(0xE0 | ((c >> 12) & 0x0F)));
                    escape(sb, (char)(0x80 | ((c >>  6) & 0x3F)));
                    escape(sb, (char)(0x80 | ((c >>  0) & 0x3F)));
                } else {
                    escape(sb, (char)(0xC0 | ((c >>  6) & 0x1F)));
                    escape(sb, (char)(0x80 | ((c >>  0) & 0x3F)));
                }
            }
        }
        return sb.toString();
    }

    /**
     * Appends the URL escape sequence for the specified char to the
     * specified StringBuffer.
     */
    private static void escape(StringBuffer s, char c) {
        s.append('%');
        s.append(Character.forDigit((c >> 4) & 0xF, 16));
        s.append(Character.forDigit(c & 0xF, 16));
    }
}