xref: /dalvik/libcore/luni/src/test/java/tests/api/java/net/URLStreamHandlerFactoryTest.java

package tests.api.java.net;

import java.io.IOException;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;

import junit.framework.TestCase;
import tests.support.Support_Configuration;
import dalvik.annotation.SideEffect;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;

@TestTargetClass(URLStreamHandlerFactory.class)
public class URLStreamHandlerFactoryTest extends TestCase {

    URLStreamHandlerFactory oldFactory = null;
    Field factoryField = null;

    boolean isTestable = false;

    boolean isOpenConnectionCalled = false;
    boolean isCreateURLStreamHandlerCalled = false;

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "createURLStreamHandler",
        args = {java.lang.String.class}
    )
    @SideEffect("Leaves wrong StreamHandlerFactory behind, affects other tests")
    public void test_createURLStreamHandler() throws MalformedURLException {

        if(isTestable) {

            TestURLStreamHandlerFactory shf = new TestURLStreamHandlerFactory();
            assertFalse(isCreateURLStreamHandlerCalled);
            URL.setURLStreamHandlerFactory(shf);
            URL url = new URL("http://" +
                    Support_Configuration.SpecialInetTestAddress);

            try {
                url.openConnection();
                assertTrue(isCreateURLStreamHandlerCalled);
                assertTrue(isOpenConnectionCalled);
            } catch (Exception e) {
                fail("Exception during test : " + e.getMessage());

            }

            try {
                URL.setURLStreamHandlerFactory(shf);
                fail("java.lang.Error was not thrown.");
            } catch(java.lang.Error e) {
                //expected
            }

            try {
                URL.setURLStreamHandlerFactory(null);
                fail("java.lang.Error was not thrown.");
            } catch(java.lang.Error e) {
                //expected
            }

        } else {
            TestURLStreamHandlerFactory shf = new TestURLStreamHandlerFactory();
            URLStreamHandler sh = shf.createURLStreamHandler("");
            assertNotNull(sh.toString());
        }
    }

    public void setUp() {
        Field [] fields = URL.class.getDeclaredFields();
        int counter = 0;
        for (Field field : fields) {
            if (URLStreamHandlerFactory.class.equals(field.getType())) {
                counter++;
                factoryField = field;
            }
        }

        if(counter == 1) {

            isTestable = true;

            factoryField.setAccessible(true);
            try {
                oldFactory = (URLStreamHandlerFactory) factoryField.get(null);
            } catch (IllegalArgumentException e) {
                fail("IllegalArgumentException was thrown during setUp: "
                        + e.getMessage());
            } catch (IllegalAccessException e) {
                fail("IllegalAccessException was thrown during setUp: "
                        + e.getMessage());
            }
        }
    }

    public void tearDown() {
        if(isTestable) {
            try {
                factoryField.set(null, oldFactory);
            } catch (IllegalArgumentException e) {
                fail("IllegalArgumentException was thrown during tearDown: "
                        + e.getMessage());
            } catch (IllegalAccessException e) {
                fail("IllegalAccessException was thrown during tearDown: "
                        + e.getMessage());
            }
        }
    }

    class TestURLStreamHandlerFactory implements URLStreamHandlerFactory {

        public URLStreamHandler createURLStreamHandler(String protocol) {
            isCreateURLStreamHandlerCalled = true;
            return new TestURLStreamHandler();
        }
    }

    class TestURLStreamHandler extends URLStreamHandler {
        @Override
        protected URLConnection openConnection(URL u) throws IOException {
            isOpenConnectionCalled = true;
            return null;
        }
    }
}