| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.lang.reflect.Field; |
| import java.net.MalformedURLException; |
| import java.net.Proxy; |
| import java.net.ProxySelector; |
| import java.net.SocketAddress; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.net.URLStreamHandler; |
| import java.net.URLStreamHandlerFactory; |
| import java.security.Permission; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import junit.framework.TestCase; |
| |
| public class OldURLTest extends TestCase { |
| |
| private static final String helloWorldString = "Hello World"; |
| |
| @Override protected void setUp() throws Exception { |
| super.setUp(); |
| } |
| |
| @Override protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| public void test_ConstructorLjava_lang_StringLjava_lang_StringILjava_lang_String() |
| throws MalformedURLException { |
| // Regression for HARMONY-83 |
| new URL("http", "apache.org", 123456789, "file"); |
| try { |
| new URL("http", "apache.org", -123, "file"); |
| fail("Assert 0: Negative port should throw exception"); |
| } catch (MalformedURLException e) { |
| // expected |
| } |
| } |
| |
| public void test_ConstructorLjava_lang_StringLjava_lang_StringLjava_lang_String() throws MalformedURLException { |
| // Strange behavior in reference, the hostname contains a ':' so it gets wrapped in '[', ']' |
| URL testURL = new URL("http", "www.apache.org:8082", "test.html#anch"); |
| assertEquals("Assert 0: wrong protocol", "http", testURL.getProtocol()); |
| assertEquals("Assert 1: wrong host", "[www.apache.org:8082]", testURL.getHost()); |
| assertEquals("Assert 2: wrong port", -1, testURL.getPort()); |
| assertEquals("Assert 3: wrong file", "/test.html", testURL.getFile()); |
| assertEquals("Assert 4: wrong anchor", "anch", testURL.getRef()); |
| |
| try { |
| new URL("hftp", "apache.org:8082", "test.html#anch"); |
| fail("Assert 0: Invalid protocol"); |
| } catch (MalformedURLException e) { |
| // expected |
| } |
| } |
| |
| public void test_java_protocol_handler_pkgs_prop() throws MalformedURLException { |
| // Regression test for Harmony-3094 |
| final String HANDLER_PKGS = "java.protocol.handler.pkgs"; |
| System.setProperty(HANDLER_PKGS, "fake|org.apache.harmony.luni.tests.java.net"); |
| |
| try { |
| new URL("test_protocol", "", "fake.jar"); |
| } catch (MalformedURLException e) { |
| // expected |
| } |
| } |
| |
| public void testHashCode() throws MalformedURLException { |
| URL testURL1 = new URL("http", "www.apache.org:8080", "test.html#anch"); |
| URL testURL2 = new URL("http", "www.apache.org:8080", "test.html#anch"); |
| URL changedURL = new URL("http", "www.apache.org:8082", |
| "test.html#anch"); |
| assertEquals("Assert 0: error in hashCode: not same", |
| testURL1.hashCode(), testURL2.hashCode()); |
| assertFalse("Assert 0: error in hashCode: should be same", testURL1 |
| .hashCode() == changedURL.hashCode()); |
| } |
| |
| public void testSetURLStreamHandlerFactory() throws MalformedURLException, IOException, IllegalArgumentException, IllegalAccessException { |
| URLStreamHandlerFactory factory = new MyURLStreamHandlerFactory(); |
| Field streamHandlerFactoryField = null; |
| int counter = 0; |
| File sampleFile = createTempHelloWorldFile(); |
| |
| URL fileURL = sampleFile.toURL(); |
| |
| |
| Field[] fields = URL.class.getDeclaredFields(); |
| |
| |
| for (Field f : fields) { |
| if (URLStreamHandlerFactory.class.equals(f.getType())) { |
| counter++; |
| streamHandlerFactoryField = f; |
| } |
| } |
| |
| if (counter != 1) { |
| fail("Error in test setup: not Factory found"); |
| } |
| |
| streamHandlerFactoryField.setAccessible(true); |
| URLStreamHandlerFactory old = (URLStreamHandlerFactory) streamHandlerFactoryField.get(null); |
| |
| try { |
| streamHandlerFactoryField.set(null, factory); |
| BufferedReader buf = new BufferedReader(new InputStreamReader( |
| fileURL.openStream()), helloWorldString.getBytes().length); |
| String nextline; |
| while ((nextline = buf.readLine()) != null) { |
| assertEquals(helloWorldString, nextline); |
| } |
| |
| buf.close(); |
| |
| } finally { |
| |
| streamHandlerFactoryField.set(null, old); |
| } |
| |
| } |
| |
| public void testURLString() throws MalformedURLException { |
| URL testURL = new URL("ftp://myname@host.dom/etc/motd"); |
| |
| assertEquals("Assert 0: wrong protocol", "ftp", testURL.getProtocol()); |
| assertEquals("Assert 1: wrong host", "host.dom", testURL.getHost()); |
| assertEquals("Assert 2: wrong port", -1, testURL.getPort()); |
| assertEquals("Assert 3: wrong userInfo", "myname", testURL |
| .getUserInfo()); |
| assertEquals("Assert 4: wrong path", "/etc/motd", testURL.getPath()); |
| |
| try { |
| new URL("ftpmyname@host.dom/etc/motd"); |
| fail("Assert 0: malformed URL should throw exception"); |
| } catch (MalformedURLException e) { |
| // expected |
| } |
| |
| } |
| |
| public void testURLURLString() throws MalformedURLException { |
| |
| URL gamelan = new URL("http://www.gamelan.com/pages/"); |
| |
| URL gamelanNetwork = new URL(gamelan, "Gamelan.net.html"); |
| URL gamelanNetworkBottom = new URL(gamelanNetwork, "#BOTTOM"); |
| assertEquals("Assert 0: wrong anchor", "BOTTOM", gamelanNetworkBottom |
| .getRef()); |
| assertEquals("Assert 1: wrong protocol", "http", gamelanNetworkBottom |
| .getProtocol()); |
| |
| // same protocol |
| URL gamelanNetworBottom2 = new URL(gamelanNetwork, |
| "http://www.gamelan.com/pages/Gamelan.net.html#BOTTOM"); |
| assertEquals(gamelanNetwork.getProtocol(), gamelanNetworBottom2.getProtocol()); |
| |
| // changed protocol |
| URL gamelanNetworkBottom3 = new URL(gamelanNetwork, |
| "ftp://www.gamelan2.com/pages/Gamelan.net.html#BOTTOM"); |
| URL absoluteNew = new URL( |
| "ftp://www.gamelan2.com/pages/Gamelan.net.html#BOTTOM"); |
| assertEquals("Host of context URL instead of new URL", "ftp", |
| gamelanNetworkBottom3.getProtocol()); |
| assertTrue("URL is context URL instead of new URL", |
| gamelanNetworkBottom3.sameFile(absoluteNew)); |
| |
| // exception testing |
| try { |
| u = null; |
| u1 = new URL(u, "somefile.java"); |
| fail("didn't throw the expected MalFormedURLException"); |
| } catch (MalformedURLException e) { |
| // ok |
| } |
| |
| // Non existing protocol |
| // exception testing |
| try { |
| u = new URL(gamelanNetwork, |
| "someFancyNewProt://www.gamelan2.com/pages/Gamelan.net.html#BOTTOM"); |
| assertTrue("someFancyNewProt".equalsIgnoreCase(u.getProtocol())); |
| } catch (MalformedURLException e) { |
| // ok |
| } |
| } |
| |
| public void testEqualsObject() throws MalformedURLException { |
| URL testURL1 = new URL("http", "www.apache.org", 8080, "test.html"); |
| URL wrongProto = new URL("ftp", "www.apache.org", 8080, "test.html"); |
| URL wrongPort = new URL("http", "www.apache.org", 8082, "test.html"); |
| URL wrongHost = new URL("http", "www.apache2.org", 8080, "test.html"); |
| URL wrongRef = new URL("http", "www.apache.org", 8080, "test2.html#BOTTOM"); |
| URL testURL2 = new URL("http://www.apache.org:8080/test.html"); |
| |
| assertFalse("Assert 0: error in equals: not same", testURL1.equals(wrongProto)); |
| assertFalse("Assert 1: error in equals: not same", testURL1.equals(wrongPort)); |
| assertFalse("Assert 2: error in equals: not same", testURL1.equals(wrongHost)); |
| assertFalse("Assert 3: error in equals: not same", testURL1.equals(wrongRef)); |
| assertEquals(testURL1, testURL2); |
| |
| URL testURL3 = new URL("http", "www.apache.org", "/test.html"); |
| URL testURL4 = new URL("http://www.apache.org/test.html"); |
| assertTrue("Assert 4: error in equals: same", testURL3.equals(testURL4)); |
| } |
| |
| public void testSameFile() throws MalformedURLException { |
| URL gamelan = new URL("file:///pages/index.html"); |
| URL gamelanFalse = new URL("file:///pages/out/index.html"); |
| |
| URL gamelanNetwork = new URL(gamelan, "#BOTTOM"); |
| assertTrue(gamelanNetwork.sameFile(gamelan)); |
| |
| assertFalse(gamelanNetwork.sameFile(gamelanFalse)); |
| |
| // non trivial test |
| URL url = new URL("http://web2.javasoft.com/some+file.html"); |
| URL url1 = new URL("http://web2.javasoft.com/some%20file.html"); |
| |
| assertFalse(url.sameFile(url1)); |
| } |
| |
| public void testGetContent() throws MalformedURLException { |
| |
| File sampleFile = createTempHelloWorldFile(); |
| |
| // read content from file |
| URL fileURL = sampleFile.toURL(); |
| |
| try { |
| InputStream output = (InputStream) fileURL.getContent(); |
| assertTrue(output.available() > 0); |
| // ok |
| } catch (Exception e) { |
| fail("Did not get output type from File URL"); |
| } |
| |
| //Exception test |
| URL invalidFile = new URL("file:///nonexistenttestdir/tstfile"); |
| |
| try { |
| invalidFile.getContent(); |
| fail("Access to invalid file worked"); |
| } catch (IOException e) { |
| //ok |
| } |
| |
| } |
| |
| public void testOpenStream() throws MalformedURLException, IOException { |
| |
| File sampleFile = createTempHelloWorldFile(); |
| |
| // read content from file |
| URL fileURL = sampleFile.toURL(); |
| BufferedReader dis = null; |
| String inputLine; |
| StringBuffer buf = new StringBuffer(32); |
| try { |
| dis = new BufferedReader( |
| new InputStreamReader(fileURL.openStream()), 32); |
| while ((inputLine = dis.readLine()) != null) { |
| buf.append(inputLine); |
| } |
| dis.close(); |
| } catch (IOException e) { |
| fail("Unexpected error in test setup: " + e.getMessage()); |
| } |
| |
| assertTrue("Assert 0: Nothing was read from file ", buf.length() > 0); |
| assertEquals("Assert 1: Wrong stream content", "Hello World", buf |
| .toString()); |
| |
| // exception test |
| |
| URL invalidFile = new URL("file:///nonexistenttestdir/tstfile"); |
| |
| try { |
| dis = new BufferedReader( |
| new InputStreamReader(invalidFile.openStream()), 32); |
| while ((inputLine = dis.readLine()) != null) { |
| buf.append(inputLine); |
| } |
| fail("Access to invalid file worked"); |
| } catch (Exception e) { |
| //ok |
| } finally { |
| dis.close(); |
| } |
| } |
| |
| public void testOpenConnection() throws MalformedURLException, IOException { |
| |
| File sampleFile = createTempHelloWorldFile(); |
| |
| byte[] ba; |
| InputStream is; |
| String s; |
| u = sampleFile.toURL(); |
| u.openConnection(); |
| |
| is = (InputStream) u.getContent(new Class[] { Object.class }); |
| is.read(ba = new byte[4096]); |
| s = new String(ba); |
| assertTrue("Incorrect content " + u |
| + " does not contain: \"Hello World\"", |
| s.indexOf("Hello World") >= 0); |
| |
| try { |
| URL u = new URL("https://a.xy.com/index.html"); |
| URLConnection conn = u.openConnection(); |
| conn.connect(); |
| fail("Should not be able to read from this site."); |
| } catch (IOException e) { |
| //ok |
| } |
| } |
| |
| public void testToURI() throws MalformedURLException, URISyntaxException { |
| String testHTTPURLString = "http://www.gamelan.com/pages/"; |
| String testFTPURLString = "ftp://myname@host.dom/etc/motd"; |
| URL testHTTPURL = new URL(testHTTPURLString); |
| URL testFTPURL = new URL(testFTPURLString); |
| |
| URI testHTTPURI = testHTTPURL.toURI(); |
| URI testFTPURI = testFTPURL.toURI(); |
| assertEquals(testHTTPURI.toString(),testHTTPURLString); |
| assertEquals(testFTPURI.toString(),testFTPURLString); |
| |
| //Exception test |
| String[] constructorTestsInvalid = new String[] { |
| "http:///a path#frag", // space char in path, not in escaped |
| // octet form, with no host |
| "http://host/a[path#frag", // an illegal char, not in escaped |
| // octet form, should throw an |
| // exception |
| "http://host/a%path#frag", // invalid escape sequence in path |
| "http://host/a%#frag", // incomplete escape sequence in path |
| |
| "http://host#a frag", // space char in fragment, not in |
| // escaped octet form, no path |
| "http://host/a#fr#ag", // illegal char in fragment |
| "http:///path#fr%ag", // invalid escape sequence in fragment, |
| // with no host |
| "http://host/path#frag%", // incomplete escape sequence in |
| // fragment |
| |
| "http://host/path?a query#frag", // space char in query, not |
| // in escaped octet form |
| "http://host?query%ag", // invalid escape sequence in query, no |
| // path |
| "http:///path?query%", // incomplete escape sequence in query, |
| // with no host |
| |
| "mailto:user^name@fklkf.com" // invalid char in scheme |
| }; |
| |
| for (String malformedURI : Arrays.asList(constructorTestsInvalid)) { |
| try { |
| URL urlQuery = new URL("http://host/a%path#frag"); |
| urlQuery.toURI(); |
| fail("Exception expected"); |
| } catch (URISyntaxException e) { |
| // ok |
| } |
| } |
| } |
| |
| public void testToString() throws MalformedURLException { |
| URL testHTTPURL = new URL("http://www.gamelan.com/pages/"); |
| URL testFTPURL = new URL("ftp://myname@host.dom/etc/motd"); |
| |
| assertEquals(testHTTPURL.toString(),testHTTPURL.toExternalForm()); |
| assertEquals(testFTPURL.toString(),testFTPURL.toExternalForm()); |
| |
| assertEquals("http://www.gamelan.com/pages/", testHTTPURL.toString()); |
| } |
| |
| public void testToExternalForm() throws MalformedURLException { |
| URL testHTTPURL = new URL("http://www.gamelan.com/pages/"); |
| URL testFTPURL = new URL("ftp://myname@host.dom/etc/motd"); |
| |
| assertEquals(testHTTPURL.toString(),testHTTPURL.toExternalForm()); |
| assertEquals(testFTPURL.toString(),testFTPURL.toExternalForm()); |
| |
| assertEquals("http://www.gamelan.com/pages/", testHTTPURL.toExternalForm()); |
| } |
| |
| public void testGetFile() throws MalformedURLException { |
| |
| File sampleFile = createTempHelloWorldFile(); |
| |
| // read content from file |
| URL fileURL = sampleFile.toURL(); |
| assertNotNull(fileURL); |
| assertEquals(sampleFile.getPath(),fileURL.getFile()); |
| } |
| |
| public void testGetPort() throws MalformedURLException { |
| URL testHTTPURL = new URL("http://www.gamelan.com/pages/"); |
| URL testFTPURL = new URL("ftp://myname@host.dom/etc/motd"); |
| |
| assertEquals(-1,testFTPURL.getPort()); |
| assertEquals(-1,testHTTPURL.getPort()); |
| |
| URL testHTTPURL8082 = new URL("http://www.gamelan.com:8082/pages/"); |
| assertEquals(8082, testHTTPURL8082.getPort()); |
| |
| } |
| |
| public void testGetProtocol() throws MalformedURLException { |
| URL testHTTPURL = new URL("http://www.gamelan.com/pages/"); |
| URL testHTTPSURL = new URL("https://www.gamelan.com/pages/"); |
| URL testFTPURL = new URL("ftp://myname@host.dom/etc/motd"); |
| URL testFile = new URL("file:///pages/index.html"); |
| URL testJarURL = new URL("jar:file:///bar.jar!/foo.jar!/Bugs/HelloWorld.class"); |
| |
| assertTrue("http".equalsIgnoreCase(testHTTPURL.getProtocol())); |
| assertTrue("https".equalsIgnoreCase(testHTTPSURL.getProtocol())); |
| assertTrue("ftp".equalsIgnoreCase(testFTPURL.getProtocol())); |
| assertTrue("file".equalsIgnoreCase(testFile.getProtocol())); |
| assertTrue("jar".equalsIgnoreCase(testJarURL.getProtocol())); |
| |
| } |
| |
| public void testGetRef() throws MalformedURLException { |
| URL gamelan = new URL("http://www.gamelan.com/pages/"); |
| |
| String output = gamelan.getRef(); |
| assertTrue(output == null || output.equals("")); |
| |
| URL gamelanNetwork = new URL(gamelan, "Gamelan.net.html#BOTTOM"); |
| assertEquals("BOTTOM", gamelanNetwork.getRef()); |
| |
| URL gamelanNetwork2 = new URL("http", "www.gamelan.com", |
| "Gamelan.network.html#BOTTOM"); |
| |
| assertEquals("BOTTOM", gamelanNetwork2.getRef()); |
| |
| } |
| |
| public void testGetQuery() throws MalformedURLException { |
| URL urlQuery = new URL( |
| "http://www.example.com/index.html?attrib1=value1&attrib2=value&attrib3#anchor"); |
| URL urlNoQuery = new URL( |
| "http://www.example.com/index.html#anchor"); |
| |
| assertEquals("attrib1=value1&attrib2=value&attrib3", urlQuery.getQuery()); |
| |
| String output = urlNoQuery.getQuery(); |
| assertTrue(output == null || "".equals(output)); |
| } |
| |
| public void testGetPath() throws MalformedURLException { |
| URL url = new URL("http://www.example.com"); |
| String output = url.getPath(); |
| |
| assertTrue("".equals(output) || output == null); |
| |
| URL url2 = new URL(url,"/foo/index.html"); |
| assertEquals("/foo/index.html",url2.getPath()); |
| } |
| |
| public void testGetUserInfo() throws MalformedURLException { |
| URL urlNoUserInfo = new URL("http://www.java2s.com:8080"); |
| URL url = new URL("ftp://myUser:password@host.dom/etc/motd"); |
| |
| assertEquals("Assert 0: Wrong user","myUser:password",url.getUserInfo()); |
| String userInfo = urlNoUserInfo.getUserInfo(); |
| assertTrue("".equals(userInfo) || null == userInfo); |
| } |
| |
| public void testGetAuthority() throws MalformedURLException, URISyntaxException { |
| // legal authority information userInfo (user,password),domain,port |
| |
| URL url = new URL("http://www.java2s.com:8080"); |
| assertEquals("Assert 0: Wrong authority ", "www.java2s.com:8080", url |
| .getAuthority()); |
| |
| URL ftpURL = new URL("ftp://myname@host.dom/etc/motd"); |
| assertEquals("Assert 1: Wrong authority ", "myname@host.dom", ftpURL |
| .getAuthority()); |
| |
| URI testURI = new URI("/relative/URI/with/absolute/path/to/resource.txt"); |
| String output = testURI.getAuthority(); |
| assertTrue("".equals(output) || null == output); |
| } |
| |
| public void testGetDefaultPort() throws MalformedURLException { |
| URL testHTTPURL = new URL("http://www.gamelan.com/pages/"); |
| URL testFTPURL = new URL("ftp://myname@host.dom/etc/motd"); |
| |
| assertEquals(21,testFTPURL.getDefaultPort()); |
| assertEquals(80,testHTTPURL.getDefaultPort()); |
| } |
| |
| private File createTempHelloWorldFile() { |
| // create content to read |
| File tmpDir = new File(System.getProperty("java.io.tmpdir")); |
| File sampleFile = null; |
| try { |
| if (tmpDir.isDirectory()) { |
| sampleFile = File.createTempFile("openStreamTest", ".txt", |
| tmpDir); |
| sampleFile.deleteOnExit(); |
| } else { |
| fail("Error in test setup java.io.tmpdir does not exist"); |
| } |
| |
| FileWriter fstream = new FileWriter(sampleFile); |
| BufferedWriter out = new BufferedWriter(fstream, 32); |
| out.write(helloWorldString); |
| // Close the output stream |
| out.close(); |
| } catch (Exception e) {// Catch exception if any |
| fail("Error: in test setup" + e.getMessage()); |
| } |
| |
| return sampleFile; |
| } |
| |
| // start HARMONY branch |
| |
| public static class MyHandler extends URLStreamHandler { |
| protected URLConnection openConnection(URL u) |
| throws IOException { |
| return null; |
| } |
| } |
| |
| URL u; |
| |
| URL u1; |
| |
| URL u2; |
| |
| boolean caught = false; |
| |
| static boolean isSelectCalled; |
| |
| |
| |
| static class MockProxySelector extends ProxySelector { |
| |
| public void connectFailed(URI uri, SocketAddress sa, IOException ioe) { |
| System.out.println("connection failed"); |
| } |
| |
| public List<Proxy> select(URI uri) { |
| isSelectCalled = true; |
| ArrayList<Proxy> proxyList = new ArrayList<Proxy>(1); |
| proxyList.add(Proxy.NO_PROXY); |
| return proxyList; |
| } |
| } |
| |
| static class MockSecurityManager extends SecurityManager { |
| |
| public void checkConnect(String host, int port) { |
| if ("127.0.0.1".equals(host)) { |
| throw new SecurityException("permission is not allowed"); |
| } |
| } |
| |
| public void checkPermission(Permission permission) { |
| if ("setSecurityManager".equals(permission.getName())) { |
| return; |
| } |
| super.checkPermission(permission); |
| } |
| |
| } |
| |
| |
| static class MyURLStreamHandler extends URLStreamHandler { |
| |
| @Override |
| protected URLConnection openConnection(URL arg0) throws IOException { |
| try { |
| URLConnection con = arg0.openConnection(); |
| con.setDoInput(true); |
| con.connect(); |
| return con; |
| } catch (Throwable e) { |
| return null; |
| } |
| } |
| |
| public void parse(URL url, String spec, int start, int end) { |
| parseURL(url, spec, start, end); |
| } |
| } |
| |
| static class MyURLStreamHandlerFactory implements URLStreamHandlerFactory { |
| |
| public static MyURLStreamHandler handler = new MyURLStreamHandler(); |
| |
| public URLStreamHandler createURLStreamHandler(String arg0) { |
| handler = new MyURLStreamHandler(); |
| return handler; |
| } |
| |
| } |
| |
| /** |
| * URLStreamHandler implementation class necessary for tests. |
| */ |
| private class TestURLStreamHandler extends URLStreamHandler { |
| public URLConnection openConnection(URL arg0) throws IOException { |
| try { |
| URLConnection con = arg0.openConnection(); |
| con.setDoInput(true); |
| con.connect(); |
| return con; |
| } catch (Throwable e) { |
| return null; |
| } |
| } |
| |
| public URLConnection openConnection(URL arg0, Proxy proxy) |
| throws IOException { |
| return super.openConnection(u, proxy); |
| } |
| } |
| |
| public void test_ConstructorLjava_lang_StringLjava_lang_StringILjava_lang_StringLjava_net_URLStreamHandler() |
| throws Exception { |
| u = new URL("http", "www.yahoo.com", 8080, "test.html#foo", null); |
| assertEquals("SSISH1 returns a wrong protocol", "http", u.getProtocol()); |
| assertEquals("SSISH1 returns a wrong host", "www.yahoo.com", u |
| .getHost()); |
| assertEquals("SSISH1 returns a wrong port", 8080, u.getPort()); |
| assertEquals("SSISH1 returns a wrong file", "/test.html", u.getFile()); |
| assertTrue("SSISH1 returns a wrong anchor: " + u.getRef(), u.getRef() |
| .equals("foo")); |
| |
| u = new URL("http", "www.yahoo.com", 8080, "test.html#foo", |
| new MyHandler()); |
| assertEquals("SSISH2 returns a wrong protocol", "http", u.getProtocol()); |
| assertEquals("SSISH2 returns a wrong host", "www.yahoo.com", u |
| .getHost()); |
| assertEquals("SSISH2 returns a wrong port", 8080, u.getPort()); |
| assertEquals("SSISH2 returns a wrong file", "/test.html", u.getFile()); |
| assertTrue("SSISH2 returns a wrong anchor: " + u.getRef(), u.getRef() |
| .equals("foo")); |
| |
| TestURLStreamHandler lh = new TestURLStreamHandler(); |
| u = new URL("http", "www.yahoo.com", 8080, "test.html#foo", |
| lh); |
| |
| try { |
| new URL(null, "1", 0, "file", lh); |
| fail("Exception expected, but nothing was thrown!"); |
| } catch (MalformedURLException e) { |
| // ok |
| } catch (NullPointerException e) { |
| // Expected NullPointerException |
| } |
| |
| } |
| |
| public void test_getContent_LJavaLangClass() throws Exception { |
| |
| File sampleFile = createTempHelloWorldFile(); |
| |
| byte[] ba; |
| String s; |
| |
| InputStream is = null; |
| |
| try { |
| u = new URL("file:///data/tmp/hyts_htmltest.html"); |
| is = (InputStream) u.getContent(new Class[] {InputStream.class}); |
| is.read(ba = new byte[4096]); |
| fail("No error occurred reading from nonexisting file"); |
| } catch (IOException e) { |
| // ok |
| } |
| |
| try { |
| u = new URL("file:///data/tmp/hyts_htmltest.html"); |
| is = (InputStream) u.getContent(new Class[] { |
| String.class, InputStream.class}); |
| is.read(ba = new byte[4096]); |
| fail("No error occurred reading from nonexisting file"); |
| } catch (IOException e) { |
| // ok |
| } |
| |
| // Check for null |
| u = sampleFile.toURL(); |
| u.openConnection(); |
| assertNotNull(u); |
| |
| s = (String) u.getContent(new Class[] {String.class}); |
| assertNull(s); |
| |
| } |
| |
| public void testURLURLStringURLStreamHandler() throws MalformedURLException { |
| u = new URL("http://www.yahoo.com"); |
| // basic ones |
| u1 = new URL(u, "file.java", new MyHandler()); |
| assertEquals("1 returns a wrong protocol", "http", u1.getProtocol()); |
| assertEquals("1 returns a wrong host", "www.yahoo.com", u1.getHost()); |
| assertEquals("1 returns a wrong port", -1, u1.getPort()); |
| assertEquals("1 returns a wrong file", "/file.java", u1.getFile()); |
| assertNull("1 returns a wrong anchor", u1.getRef()); |
| |
| u1 = new URL(u, "systemresource:/+/FILE0/test.java", new MyHandler()); |
| assertEquals("2 returns a wrong protocol", "systemresource", u1 |
| .getProtocol()); |
| assertTrue("2 returns a wrong host", u1.getHost().equals("")); |
| assertEquals("2 returns a wrong port", -1, u1.getPort()); |
| assertEquals("2 returns a wrong file", "/+/FILE0/test.java", u1 |
| .getFile()); |
| assertNull("2 returns a wrong anchor", u1.getRef()); |
| |
| u1 = new URL(u, "dir1/dir2/../file.java", null); |
| assertEquals("3 returns a wrong protocol", "http", u1.getProtocol()); |
| assertEquals("3 returns a wrong host", "www.yahoo.com", u1.getHost()); |
| assertEquals("3 returns a wrong port", -1, u1.getPort()); |
| assertEquals("3 returns a wrong file", "/dir1/file.java", u1.getFile()); |
| assertNull("3 returns a wrong anchor", u1.getRef()); |
| |
| // test for question mark processing |
| u = new URL("http://www.foo.com/d0/d1/d2/cgi-bin?foo=bar/baz"); |
| |
| // test for relative file and out of bound "/../" processing |
| u1 = new URL(u, "../dir1/dir2/../file.java", new MyHandler()); |
| assertTrue("A) returns a wrong file: " + u1.getFile(), u1.getFile() |
| .equals("/d0/d1/dir1/file.java")); |
| |
| // test for absolute and relative file processing |
| u1 = new URL(u, "/../dir1/dir2/../file.java", null); |
| assertEquals("B) returns a wrong file", "/dir1/file.java", |
| u1.getFile()); |
| |
| URL one; |
| try { |
| one = new URL("http://www.ibm.com"); |
| } catch (MalformedURLException ex) { |
| // Should not happen. |
| throw new RuntimeException(ex.getMessage()); |
| } |
| try { |
| new URL(one, (String) null, null); |
| fail("Specifying null spec on URL constructor should throw MalformedURLException"); |
| } catch (MalformedURLException e) { |
| // expected |
| } |
| |
| } |
| |
| public void test_toExternalForm_Relative() throws MalformedURLException { |
| String strURL = "http://a/b/c/d;p?q"; |
| String ref = "?y"; |
| URL url = new URL(new URL(strURL), ref); |
| assertEquals("http://a/b/c/d;p?y", url.toExternalForm()); |
| } |
| |
| public void test_toExternalForm_Absolute() throws MalformedURLException { |
| String strURL = "http://localhost?name=value"; |
| URL url = new URL(strURL); |
| assertEquals(strURL, url.toExternalForm()); |
| |
| strURL = "http://localhost?name=value/age=12"; |
| url = new URL(strURL); |
| assertEquals(strURL, url.toExternalForm()); |
| } |
| } |
