/*
 * 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 org.netbeans.api.java.classpath;

import java.io.File;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.FileOutputStream;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.jar.JarOutputStream;
import java.util.logging.Level;
import java.util.zip.ZipEntry;
import org.netbeans.junit.Log;
import org.netbeans.junit.NbTestCase;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.netbeans.spi.java.classpath.ClassPathImplementation;
import org.netbeans.spi.java.classpath.ClassPathFactory;
import org.netbeans.spi.java.classpath.FilteringPathResourceImplementation;
import org.netbeans.spi.java.classpath.PathResourceImplementation;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.BaseUtilities;
import org.openide.util.Utilities;
import org.openide.util.test.MockPropertyChangeListener;

public class ClassPathTest extends NbTestCase {

    public ClassPathTest(String testName) {
        super(testName);
    }

    protected @Override void setUp() throws Exception {
        super.setUp();
        clearWorkDir();
    }

    private File getBaseDir() throws Exception {
        return FileUtil.normalizeFile(getWorkDir());
    }

    /**
     * Tests ClassPath.getResourceName ();
     */
    public void testGetResourceName() throws Exception {
        File f = getBaseDir();        
        f = new File(f.getPath()+"/w.e.i.r.d/f  o  l  d  e  r");
        f.mkdirs();
        File f2 = new File(f, "org/netbeans/test");
        f2.mkdirs();
        File f3 = new File(f2, "Main.java");
        f3.createNewFile();
        File f4 = new File(f2, ".dotname");
        f4.createNewFile();
        File f5 = new File(f2, ".dotname.dotext");
        f5.createNewFile();

        FileObject cpRoot = FileUtil.toFileObject(f);
        FileObject cpItem = FileUtil.toFileObject(f2);
        FileObject clazz = FileUtil.toFileObject(f3);
        FileObject dotname = FileUtil.toFileObject(f4);
        FileObject dotnameDotext = FileUtil.toFileObject(f5);
        ClassPath cp = ClassPathSupport.createClassPath(new FileObject[]{cpRoot});
        String pkg = cp.getResourceName(cpItem);
        assertEquals("org/netbeans/test", pkg);
        
        pkg = cp.getResourceName(cpItem, '.', true);
        assertEquals("org.netbeans.test", pkg);
        
        pkg = cp.getResourceName(cpItem, '.', false);
        assertEquals("org.netbeans.test", pkg);
        
        pkg = cp.getResourceName(cpItem, '#', true);
        assertEquals("org#netbeans#test", pkg);
        
        pkg = cp.getResourceName(cpItem, '#', false);
        assertEquals("org#netbeans#test", pkg);
        
        pkg = cp.getResourceName(clazz);
        assertEquals("org/netbeans/test/Main.java", pkg);
        
        pkg = cp.getResourceName(clazz, '.', true);
        assertEquals("org.netbeans.test.Main.java", pkg);
        
        pkg = cp.getResourceName(clazz, '.', false);
        assertEquals("org.netbeans.test.Main", pkg);
        
        pkg = cp.getResourceName(clazz, '@', true);
        assertEquals("org@netbeans@test@Main.java", pkg);
        
        pkg = cp.getResourceName(clazz, '@', false);
        assertEquals("org@netbeans@test@Main", pkg);

        //bug #152427
        pkg = cp.getResourceName(dotname, '/', false);
        assertEquals("org/netbeans/test/.dotname", pkg);
        pkg = cp.getResourceName(dotnameDotext, '/', false);
        assertEquals("org/netbeans/test/.dotname", pkg);
    }
    
    /**
     * Tests ClassPath.findAllResources(), ClassPath.findResoruce(), 
     * ClassPath.contains (), ClassPath.findOwnerRoot(),
     * ClassPath.isResourceVisible ()
     */
    public void testGetResource () throws Exception {
        File root_1 = new File (getBaseDir(),"root_1");
        root_1.mkdir();
        File root_2 = new File (getBaseDir(),"root_2");
        root_2.mkdir();
        FileObject[] roots = new FileObject [] {
            FileUtil.toFileObject(root_1),
            FileUtil.toFileObject(root_2),
        };
        
        FileObject tmp = roots[0].createFolder("org");
        tmp = tmp.createFolder("me");
        FileObject testFo_1 = tmp.createData("Foo","txt");
        tmp = roots[1].createFolder("org");
        tmp = tmp.createFolder("me");
        FileObject testFo_2 = tmp.createData("Foo","txt");        
        ClassPath cp = ClassPathSupport.createClassPath(roots);        
        
        //findResource
        assertTrue(cp.findResource ("org/me/Foo.txt")==testFo_1);
        assertTrue (cp.findResource("org/me/None.txt")==null);
        
        //findAllResources
        List<FileObject> res = cp.findAllResources ("org/me/Foo.txt");
        assertTrue (res.size() == 2);
        assertTrue (res.contains(testFo_1));
        assertTrue (res.contains(testFo_2));
        
        //contains
        assertTrue (cp.contains (testFo_1));
        assertTrue (cp.contains (testFo_2));
        assertFalse (cp.contains (roots[0].getParent()));
        
        //findOwnerRoot
        assertTrue (cp.findOwnerRoot(testFo_1)==roots[0]);
        assertTrue (cp.findOwnerRoot(testFo_2)==roots[1]);

        /*
        //isResourceVisible
        assertTrue (cp.isResourceVisible(testFo_1));
        assertFalse (cp.isResourceVisible(testFo_2));
         */
        
        cp = null;
        roots[0].delete();
        roots[1].delete();
    }
    
    /**
     * Test ClassPath.getRoots(), ClassPath.addPropertyChangeListener (),
     * ClassPath.entries () and classpath SPI.
     */
    public void testListening() throws Exception {
        // XXX unreliable, would be improved by usage of TestFileUtils methods:

        File root_1 = new File (getBaseDir(),"root_1");
        root_1.mkdir();
        File root_2 = new File (getBaseDir(),"root_2");
        root_2.mkdir();
        File root_3 = new File (getBaseDir(),"root_3.jar");
        JarOutputStream out = new JarOutputStream ( new FileOutputStream (root_3));
        try {            
            out.putNextEntry(new ZipEntry("test.txt"));
            out.write ("test".getBytes());
        } finally {
            out.close ();
        }        
        assertNotNull("Cannot find file",FileUtil.toFileObject(root_1));
        assertNotNull("Cannot find file",FileUtil.toFileObject(root_2));
        assertNotNull("Cannot find file",FileUtil.toFileObject(root_3));
        TestClassPathImplementation impl = new TestClassPathImplementation();
	ClassPath cp = ClassPathFactory.createClassPath (impl);
        impl.addResource(Utilities.toURI(root_1).toURL());
        cp.addPropertyChangeListener (impl);
        impl.addResource (Utilities.toURI(root_2).toURL());
        impl.assertEvents(ClassPath.PROP_ENTRIES, ClassPath.PROP_ROOTS);
        assertTrue (cp.getRoots().length==2);
        impl.removeResource (Utilities.toURI(root_2).toURL());
        impl.assertEvents(ClassPath.PROP_ENTRIES, ClassPath.PROP_ROOTS);
        assertTrue (cp.getRoots().length==1);
        FileObject fo = cp.getRoots()[0];
        FileObject parentFolder = fo.getParent();        
        fo.delete();
        impl.assertEvents(ClassPath.PROP_ROOTS);
        assertTrue (cp.getRoots().length==0);
        parentFolder.createFolder("root_1");
        assertTrue (cp.getRoots().length==1);
        impl.assertEvents(ClassPath.PROP_ROOTS);
        FileObject archiveFile = FileUtil.toFileObject(root_3);
        impl.addResource(FileUtil.getArchiveRoot(archiveFile.toURL()));
        assertEquals (cp.getRoots().length,2);
        impl.assertEvents(ClassPath.PROP_ENTRIES, ClassPath.PROP_ROOTS);
        root_3.delete();
        root_3 = new File (getBaseDir(),"root_3.jar");
        Thread.sleep(1000);
        out = new JarOutputStream ( new FileOutputStream (root_3));
        try {            
            out.putNextEntry(new ZipEntry("test2.txt"));
            out.write ("test2".getBytes());
        } finally {
            out.close ();
        }
        archiveFile.refresh();
        impl.assertEvents(ClassPath.PROP_ROOTS);
        root_1.delete();
        root_2.delete();
        root_3.delete();
        cp = null;
    }

    public void testListening2() throws Exception {
        // Checks that changes in PathResourceImplementation.PROP_ROOTS matter.
        class FiringPRI implements PathResourceImplementation {
            private URL[] roots = new URL[0];
            public URL[] getRoots() {
                return roots;
            }
            void changeRoots(URL[] nue) {
                roots = nue;
                pcs.firePropertyChange(PROP_ROOTS, null, null);
            }
            public ClassPathImplementation getContent() {
                return null;
            }
            PropertyChangeSupport pcs = new PropertyChangeSupport(this);
            public void addPropertyChangeListener(PropertyChangeListener listener) {
                pcs.addPropertyChangeListener(listener);
            }
            public void removePropertyChangeListener(PropertyChangeListener listener) {
                pcs.removePropertyChangeListener(listener);
            }
        }
        FiringPRI pri = new FiringPRI();
        TestClassPathImplementation impl = new TestClassPathImplementation();
        impl.addResource(pri);
        ClassPath cp = ClassPathFactory.createClassPath(impl);
        assertEquals(Collections.emptyList(), Arrays.asList(cp.getRoots()));
        cp.addPropertyChangeListener(impl);
        File d = new File(getBaseDir(), "d");
        d.mkdir();
        pri.changeRoots(new URL[] {Utilities.toURI(d).toURL()});
        impl.assertEvents(ClassPath.PROP_ENTRIES, ClassPath.PROP_ROOTS);
        assertEquals(Collections.singletonList(FileUtil.toFileObject(d)), Arrays.asList(cp.getRoots()));
    }
    
    public void testChangesAcknowledgedWithoutListener() throws Exception {
        // Discovered in #72573.
        clearWorkDir();
        ClassPath cp = ClassPathSupport.createClassPath(FileUtil.urlForArchiveOrDir(new File(getWorkDir(), "root")));
        assertEquals("nothing there yet", null, cp.findResource("f"));
        FileObject f = FileUtil.createData(FileUtil.toFileObject(getWorkDir()), "root/f");
        assertEquals("found new file", f, cp.findResource("f"));
        f.delete();
        assertEquals("again empty", null, cp.findResource("f"));
    }

    public void testFlags() {
        final FlaggedClassPathImpl fcpImpl = new FlaggedClassPathImpl();
        final ClassPath cp = ClassPathFactory.createClassPath(fcpImpl);
        Set<ClassPath.Flag> flags = cp.getFlags();
        assertNotNull(flags);
        assertTrue(flags.isEmpty());
        fcpImpl.setFlags(EnumSet.of(ClassPath.Flag.INCOMPLETE));
        flags = cp.getFlags();
        assertNotNull(flags);
        assertEquals(1, flags.size());
        assertEquals(ClassPath.Flag.INCOMPLETE, flags.iterator().next());
        fcpImpl.setFlags(EnumSet.noneOf(ClassPath.Flag.class));
        flags = cp.getFlags();
        assertNotNull(flags);
        assertTrue(flags.isEmpty());
    }

    public void testFlagsFiring() {
        final FlaggedClassPathImpl fcpImpl = new FlaggedClassPathImpl();
        final ClassPath cp = ClassPathFactory.createClassPath(fcpImpl);
        Set<ClassPath.Flag> flags = cp.getFlags();
        assertNotNull(flags);
        assertTrue(flags.isEmpty());
        final MockPropertyChangeListener pl = new MockPropertyChangeListener(ClassPath.PROP_FLAGS);
        cp.addPropertyChangeListener(pl);
        fcpImpl.setFlags(EnumSet.of(ClassPath.Flag.INCOMPLETE));
        pl.assertEventCount(1);
        fcpImpl.setFlags(EnumSet.noneOf(ClassPath.Flag.class));
        pl.assertEventCount(1);
    }

    static final class TestClassPathImplementation implements ClassPathImplementation, PropertyChangeListener {

        private final PropertyChangeSupport support = new PropertyChangeSupport (this);
        private final List<PathResourceImplementation> resources = new ArrayList<PathResourceImplementation> ();
        private final SortedSet<String> events = new TreeSet<String>();

        public synchronized void addResource (URL resource) {
            PathResourceImplementation pr = ClassPathSupport.createResource (resource);
            addResource(pr);
        }

        public synchronized void addResource(PathResourceImplementation pr) {
            this.resources.add (pr);
            this.support.firePropertyChange (ClassPathImplementation.PROP_RESOURCES,null,null);
        }

        public synchronized void removeResource (URL resource) {
            for (Iterator<PathResourceImplementation> it = this.resources.iterator(); it.hasNext();) {
                PathResourceImplementation pr = it.next ();
                if (Arrays.asList(pr.getRoots()).contains (resource)) {
                    this.resources.remove (pr);
                    this.support.firePropertyChange (ClassPathImplementation.PROP_RESOURCES,null,null);
                    break;
                }
            }
        }

        public synchronized List<? extends PathResourceImplementation> getResources() {
            return this.resources;
        }

        public void addPropertyChangeListener(PropertyChangeListener listener) {
            this.support.addPropertyChangeListener (listener);
        }

        public void removePropertyChangeListener(PropertyChangeListener listener) {
            this.support.removePropertyChangeListener (listener);
        }

        public void propertyChange (PropertyChangeEvent event) {
            events.add(event.getPropertyName());
        }

        void assertEvents(String... events) {
            assertEquals(new TreeSet<String>(Arrays.asList(events)), this.events);
            this.events.clear();
        }
    }

    public void testFilteredClassPaths() throws Exception {
        FileObject bd = FileUtil.toFileObject(getBaseDir());
        FileObject u1fo = bd.createFolder("u1");
        FileObject u2fo = bd.createFolder("u2");
        final URL u1 = u1fo.toURL();
        final URL u2 = u2fo.toURL();
        class FPRI implements FilteringPathResourceImplementation {
            private int modulus = 2;
            public void changeIncludes(int modulus) {
                this.modulus = modulus;
                pcs.firePropertyChange(PROP_INCLUDES, null, null);
            }
            public URL[] getRoots() {
                return new URL[] {u1, u2};
            }
            public boolean includes(URL root, String resource) {
                int offset;
                if (root.equals(u1)) {
                    offset = 0;
                } else if (root.equals(u2)) {
                    offset = 1;
                } else {
                    throw new IllegalArgumentException(root.toString());
                }
                return (offset + resource.length()) % modulus == 0;
            }
            public ClassPathImplementation getContent() {
                return null;
            }
            private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
            public void addPropertyChangeListener(PropertyChangeListener listener) {
                pcs.addPropertyChangeListener(listener);
            }
            public void removePropertyChangeListener(PropertyChangeListener listener) {
                pcs.removePropertyChangeListener(listener);
            }
        }
        FPRI pr = new FPRI();
        TestClassPathImplementation impl = new TestClassPathImplementation();
        impl.addResource(pr);
        ClassPath cp = ClassPathFactory.createClassPath(impl);
        FileObject xx1 = u1fo.createData("xx");
        FileObject xxx1 = u1fo.createData("xxx");
        FileObject xy1 = FileUtil.createData(u1fo, "x/y");
        FileObject x_1 = u1fo.createData("x ");
        String cau = "\u010Dau";
        FileObject cau1 = u1fo.createData(cau);
        FileObject folder = u1fo.createFolder("folder");
        FileObject foldr = u1fo.createFolder("foldr");
        FileObject xx2 = u2fo.createData("xx");
        FileObject xxx2 = u2fo.createData("xxx");
        FileObject xy2 = FileUtil.createData(u2fo, "x/y");
        FileObject x_2 = u2fo.createData("x ");
        FileObject cau2 = u2fo.createData(cau);
        assertEquals(Arrays.asList(u1fo, u2fo), Arrays.asList(cp.getRoots()));
        assertTrue(cp.contains(xx1));
        assertTrue(cp.contains(x_1));
        assertFalse(cp.contains(xxx1));
        assertFalse(cp.contains(cau1));
        assertFalse(cp.contains(xy1));
        assertFalse(cp.contains(xx2));
        assertFalse(cp.contains(x_2));
        assertTrue(cp.contains(xxx2));
        assertTrue(cp.contains(cau2));
        assertTrue(cp.contains(xy2));
        assertFalse(cp.contains(folder));
        assertTrue(cp.contains(foldr));
        assertEquals(xx1, cp.findResource("xx"));
        assertEquals(x_1, cp.findResource("x "));
        assertEquals(xxx2, cp.findResource("xxx"));
        assertEquals(cau2, cp.findResource(cau));
        assertEquals(xy2, cp.findResource("x/y"));
        assertEquals(null, cp.findResource("folder"));
        assertEquals(foldr, cp.findResource("foldr"));
        assertEquals(Collections.singletonList(xx1), cp.findAllResources("xx"));
        assertEquals(Collections.singletonList(x_1), cp.findAllResources("x "));
        assertEquals(Collections.singletonList(xxx2), cp.findAllResources("xxx"));
        assertEquals(Collections.singletonList(cau2), cp.findAllResources(cau));
        assertEquals(Collections.singletonList(xy2), cp.findAllResources("x/y"));
        assertEquals(Collections.emptyList(), cp.findAllResources("folder"));
        assertEquals(Collections.singletonList(foldr), cp.findAllResources("foldr"));
        assertEquals("xx", cp.getResourceName(xx1));
        assertEquals("x ", cp.getResourceName(x_1));
        assertEquals("xxx", cp.getResourceName(xxx1));
        assertEquals(cau, cp.getResourceName(cau1));
        assertEquals("x/y", cp.getResourceName(xy1));
        assertEquals("folder", cp.getResourceName(folder));
        assertEquals("foldr", cp.getResourceName(foldr));
        assertEquals(u1fo, cp.findOwnerRoot(xx1));
        assertEquals(u1fo, cp.findOwnerRoot(x_1));
        assertEquals(u1fo, cp.findOwnerRoot(xxx1));
        assertEquals(u1fo, cp.findOwnerRoot(cau1));
        assertEquals(u1fo, cp.findOwnerRoot(xy1));
        assertEquals(u1fo, cp.findOwnerRoot(folder));
        assertEquals(u1fo, cp.findOwnerRoot(foldr));
        assertTrue(cp.isResourceVisible(xx1));
        assertTrue(cp.isResourceVisible(x_1));
        assertFalse(cp.isResourceVisible(xxx1));
        assertFalse(cp.isResourceVisible(cau1));
        assertFalse(cp.isResourceVisible(xy1));
        assertFalse(cp.isResourceVisible(folder));
        assertTrue(cp.isResourceVisible(foldr));
        ClassPath.Entry e1 = cp.entries().get(0);
        assertTrue(e1.includes("xx"));
        assertTrue(e1.includes("x "));
        assertFalse(e1.includes("xxx"));
        assertFalse(e1.includes(cau));
        assertFalse(e1.includes("x/y"));
        assertFalse(e1.includes("folder/"));
        assertTrue(e1.includes("foldr/"));
        assertTrue(e1.includes(xx1));
        assertTrue(e1.includes(x_1));
        assertFalse(e1.includes(xxx1));
        assertFalse(e1.includes(cau1));
        assertFalse(e1.includes(xy1));
        assertFalse(e1.includes(folder));
        assertTrue(e1.includes(foldr));
        try {
            e1.includes(xx2);
            fail();
        } catch (IllegalArgumentException iae) {}
        assertTrue(e1.includes(xx1.toURL()));
        assertTrue(e1.includes(x_1.toURL()));
        assertFalse(e1.includes(xxx1.toURL()));
        assertFalse(e1.includes(cau1.toURL()));
        assertFalse(e1.includes(xy1.toURL()));
        assertFalse(e1.includes(folder.toURL()));
        assertTrue(e1.includes(foldr.toURL()));
        try {
            e1.includes(xx2.toURL());
            fail();
        } catch (IllegalArgumentException iae) {}
        cp.addPropertyChangeListener(impl);
        pr.changeIncludes(3);
        impl.assertEvents(ClassPath.PROP_INCLUDES);
        assertFalse(cp.contains(xx1));
        assertFalse(cp.contains(x_1));
        assertTrue(cp.contains(xxx1));
        assertTrue(cp.contains(cau1));
        assertTrue(cp.contains(xy1));
        assertTrue(cp.contains(xx2));
        assertTrue(cp.contains(x_2));
        assertFalse(cp.contains(xxx2));
        assertFalse(cp.contains(cau2));
        assertFalse(cp.contains(xy2));
        assertEquals(xx2, cp.findResource("xx"));
        assertEquals(x_2, cp.findResource("x "));
        assertEquals(xxx1, cp.findResource("xxx"));
        assertEquals(cau1, cp.findResource(cau));
        assertEquals(xy1, cp.findResource("x/y"));
        e1 = cp.entries().get(0);
        assertFalse(e1.includes("xx"));
        assertFalse(e1.includes("x "));
        assertTrue(e1.includes("xxx"));
        assertTrue(e1.includes(cau));
        assertTrue(e1.includes("x/y"));
        assertFalse(e1.includes(xx1));
        assertFalse(e1.includes(x_1));
        assertTrue(e1.includes(xxx1));
        assertTrue(e1.includes(cau1));
        assertTrue(e1.includes(xy1));
        assertFalse(e1.includes(xx1.toURL()));
        assertFalse(e1.includes(x_1.toURL()));
        assertTrue(e1.includes(xxx1.toURL()));
        assertTrue(e1.includes(cau1.toURL()));
        assertTrue(e1.includes(xy1.toURL()));
    }

    public void testFpriChangeFiring() throws Exception {
        class FPRI implements FilteringPathResourceImplementation {
            URL root;
            PropertyChangeSupport pcs = new PropertyChangeSupport(this);
            FPRI(URL root) {
                this.root = root;
            }
            public boolean includes(URL root, String resource) {
                return true;
            }
            public URL[] getRoots() {
                return new URL[] {root};
            }
            public ClassPathImplementation getContent() {
                return null;
            }
            public void addPropertyChangeListener(PropertyChangeListener listener) {
                pcs.addPropertyChangeListener(listener);
            }
            public void removePropertyChangeListener(PropertyChangeListener listener) {
                pcs.removePropertyChangeListener(listener);
            }
            void fire(Object propid) {
                PropertyChangeEvent e = new PropertyChangeEvent(this, FilteringPathResourceImplementation.PROP_INCLUDES, null, null);
                e.setPropagationId(propid);
                pcs.firePropertyChange(e);
            }
        }
        FPRI fpri1 = new FPRI(FileUtil.urlForArchiveOrDir(new File(getWorkDir(), "src1")));
        FPRI fpri2 = new FPRI(FileUtil.urlForArchiveOrDir(new File(getWorkDir(), "src2")));
        class L implements PropertyChangeListener {
            int cnt;
            public void propertyChange(PropertyChangeEvent e) {
                if (ClassPath.PROP_INCLUDES.equals(e.getPropertyName())) {
                    cnt++;
                }
            }
        }
        ClassPath cp = ClassPathSupport.createClassPath(Arrays.asList(fpri1, fpri2));
        L l = new L();
        cp.addPropertyChangeListener(l);
        fpri1.fire(null);
        assertEquals(0, l.cnt);
        cp.entries();
        fpri1.fire(null);
        assertEquals(1, l.cnt);
        fpri2.fire(null);
        assertEquals(2, l.cnt);
        fpri1.fire("hello");
        assertEquals(3, l.cnt);
        fpri2.fire("goodbye");
        assertEquals(4, l.cnt);
        fpri1.fire("fixed");
        assertEquals(5, l.cnt);
        fpri2.fire("fixed");
        assertEquals(5, l.cnt);
        fpri1.fire("new");
        assertEquals(6, l.cnt);
    }

    public void testLeakingClassPath() throws Exception {
        ClassPath cp = ClassPathSupport.createClassPath(new URL("file:///a/"), new URL("file:///b/"));
        ClassPath proxyCP = ClassPathSupport.createProxyClassPath(cp);
        Reference<ClassPath> proxy = new WeakReference<ClassPath>(proxyCP);
        
        proxyCP.entries();
        
        proxyCP = null;
        
        assertGC("the proxy classpath needs to GCable", proxy);
    }
    
    public void testGetClassLoaderPerf () throws Exception {
        final String bootPathProp = System.getProperty("sun.boot.class.path");  //NOI18N
        List<URL> roots = new ArrayList<URL> ();
        StringTokenizer tk = new StringTokenizer (bootPathProp,File.pathSeparator);
        if (tk.hasMoreTokens()) {
            final String path = tk.nextToken();
            final File f = FileUtil.normalizeFile(new File (path));
            if (f.canRead()) {
                roots.add(Utilities.toURI(f).toURL());
            }
        }
        final ClassLoader bootLoader = new URLClassLoader(roots.toArray(new URL[roots.size()]), null);
        
        final String classPathProp = System.getProperty("java.class.path");     //NOI18N
        roots = new ArrayList<URL> ();
        List<URL> roots2 = new ArrayList<URL>();
        tk = new StringTokenizer (classPathProp,File.pathSeparator);
        while (tk.hasMoreTokens()) {
            final String path = tk.nextToken();
            final File f = FileUtil.normalizeFile(new File (path));
            if (!f.canRead()) {
                continue;
            }
            URL url = Utilities.toURI(f).toURL();
            roots2.add(url);
            if (FileUtil.isArchiveFile(url)) {
                url = FileUtil.getArchiveRoot(url);
            }
            roots.add(url);
        }
        
        final ClassPath cp = ClassPathSupport.createClassPath(roots.toArray(new URL[roots.size()]));
//        final ClassLoader loader = ClassLoaderSupport.create(cp,bootLoader);
//        final ClassLoader loader = new URLClassLoader(roots.toArray(new URL[roots.size()]),bootLoader);
        final ClassLoader loader = new URLClassLoader(roots2.toArray(new URL[roots2.size()]),bootLoader);
        
        final Set<String> classNames = getClassNames (cp);
        int noLoaded = 0;
        int noFailed = 0;
        long st = System.currentTimeMillis();
        for (String className : classNames) {
            try {
                final Class<?> c = loader.loadClass(className);
                noLoaded++;
            } catch (ClassNotFoundException | NoClassDefFoundError | SecurityException e) {
                noFailed++;
            }
        }
        long et = System.currentTimeMillis();
        System.out.println("Loaded: " + noLoaded + " in: " + (et-st)+"ms");
    }

    public void testMemoryLeak183370() throws Exception {
        final File  wd = getWorkDir();
        class TestResource implements PathResourceImplementation {
            private final File f;
            private final PropertyChangeSupport sup = new PropertyChangeSupport(this);
            public TestResource(final File f){
                this.f=f;
            }
            @Override
            public URL[] getRoots() {
                return new URL[]{FileUtil.urlForArchiveOrDir(f)};
            }
            @Override
            public ClassPathImplementation getContent() {
                return null;
            }
            @Override
            public void addPropertyChangeListener(PropertyChangeListener listener) {
                sup.addPropertyChangeListener(listener);
            }
            @Override
            public void removePropertyChangeListener(PropertyChangeListener listener) {
                sup.removePropertyChangeListener(listener);
            }
        };
        class TestCPImpl implements ClassPathImplementation {
            private final List<? extends PathResourceImplementation> result = Arrays.asList(new TestResource(new File(wd,"1")), new TestResource(new File(wd,"2")));
            private final PropertyChangeSupport sup = new PropertyChangeSupport(this);

            @Override
            public List<? extends PathResourceImplementation> getResources() {
                return result;
            }
            @Override
            public void addPropertyChangeListener(PropertyChangeListener listener) {
                sup.addPropertyChangeListener(listener);
            }
            @Override
            public void removePropertyChangeListener(PropertyChangeListener listener) {
                sup.removePropertyChangeListener(listener);
            }
        };
        final TestCPImpl impl = new TestCPImpl();
        final ClassPath cp = ClassPathFactory.createClassPath(impl);
        assertEquals(2 ,cp.entries().size());
        assertEquals(impl.getResources().get(0).getRoots()[0] ,cp.entries().get(0).getURL());
        assertEquals(impl.getResources().get(1).getRoots()[0] ,cp.entries().get(1).getURL());
        assertEquals(1,((TestResource)impl.getResources().get(0)).sup.getPropertyChangeListeners().length);
        assertEquals(1,((TestResource)impl.getResources().get(1)).sup.getPropertyChangeListeners().length);
        impl.sup.firePropertyChange(ClassPathImplementation.PROP_RESOURCES,null,null);
        assertEquals(2 ,cp.entries().size());
        assertEquals(impl.getResources().get(0).getRoots()[0] ,cp.entries().get(0).getURL());
        assertEquals(impl.getResources().get(1).getRoots()[0] ,cp.entries().get(1).getURL());
        assertEquals(1,((TestResource)impl.getResources().get(0)).sup.getPropertyChangeListeners().length);
        assertEquals(1,((TestResource)impl.getResources().get(1)).sup.getPropertyChangeListeners().length);
    }
    
    private Set<String> getClassNames (final ClassPath cp) {
        Set<String> classNames = new HashSet<String> ();
        for (FileObject root : cp.getRoots()) {
            Enumeration<? extends FileObject> fos = root.getChildren(true);
            while (fos.hasMoreElements()) {
                FileObject fo = fos.nextElement();
                if (isImportant (fo)) {
                    classNames.add(cp.getResourceName(fo, '.', false));
                }
            }
        }
        return classNames;
    }
    
    private boolean isImportant (final FileObject fo) {
        if (fo.isFolder()) {
            return false;
        }
        if (!"class".equals(fo.getExt())) {      //NOI18N
            return false;
        }
        return !fo.getName().contains("$");     //NOI18N
                
    }

    public void testJVMPathConversion() throws Exception {
        String root = Utilities.toURI(getWorkDir()).toString();
        ClassPath cp = ClassPathSupport.createClassPath(
                new URL(root + "folder/"),
                new URL("jar:" + root + "file.zip!/"),
                new URL("jar:" + root + "file.zip!/subdir/"));
        assertEquals(massagePath("<root>/folder:<root>/file.zip"), cp.toString(ClassPath.PathConversionMode.SKIP));
        assertEquals(massagePath("<root>/folder:<root>/file.zip:") + "jar:" + root + "file.zip!/subdir/", cp.toString(ClassPath.PathConversionMode.PRINT));
        try {
            cp.toString(ClassPath.PathConversionMode.FAIL);
            fail();
        } catch (IllegalArgumentException x) {/* OK */}
        CharSequence warnings = Log.enable(ClassPath.class.getName(), Level.WARNING);
        assertEquals(massagePath("<root>/folder:<root>/file.zip"), cp.toString(ClassPath.PathConversionMode.WARN));
        assertTrue(warnings.toString(), warnings.toString().contains("subdir"));

        cp = ClassPathSupport.createClassPath(
                new URL(root + "folder/"),
                new URL("jar:" + root + "file.zip!/"));
        assertEquals(cp.toString(), ClassPathSupport.createClassPath(cp.toString()).toString());
        // XXX could also test IAE (tricky - need to have a URLMapper in Lookup, etc.)
    }

    public void testInArchivePaths() throws Exception {
        final String root = Utilities.toURI(getWorkDir()).toString();
        //Test regular folder
        ClassPath cp = ClassPathSupport.createClassPath(new URL(root + "folder/"));
        assertEquals(massagePath("<root>/folder"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.INCLUDE));
        assertEquals(massagePath("<root>/folder"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.EXCLUDE));
        assertEquals(massagePath("<root>/folder"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.FAIL));
        //Test archive with no in archive path
        cp = ClassPathSupport.createClassPath(new URL("jar:" + root + "file.zip!/"));
        assertEquals(massagePath("<root>/file.zip"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.INCLUDE));
        assertEquals(massagePath("<root>/file.zip"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.EXCLUDE));
        assertEquals(massagePath("<root>/file.zip"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.FAIL));
        //Test archive with in archive path
        cp = ClassPathSupport.createClassPath(new URL("jar:" + root + "file.zip!/java.base/"));
        assertEquals(massagePath("<root>/file.zip!/java.base/"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.INCLUDE));
        assertEquals(massagePath("<root>/file.zip"), cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.EXCLUDE));
        try {
            cp.toString(ClassPath.PathConversionMode.FAIL, ClassPath.PathEmbeddingMode.FAIL);
            assertTrue("Should be unreachable",false);
        } catch (IllegalArgumentException iae) {
            //IAE should be thrown
        }
    }

    public void testEmptyClassPath() throws Exception {
        final ClassPath cp = ClassPath.EMPTY;
        assertNotNull(cp);
        assertTrue(cp.entries().isEmpty());
    }

    private String massagePath(String path) throws Exception {
        return path.replace('/', File.separatorChar).replace(':', File.pathSeparatorChar).replace("<root>", getWorkDir().getAbsolutePath());
    }

    public void testInvalidURLs() throws Exception {
        try {
            ClassPathSupport.createClassPath(new URL("file:/some/jar/without/correct/protocol.jar"));
            fail();
        } catch (IllegalArgumentException x) {/* right */}
        try {
            ClassPathSupport.createClassPath(new URL("file:/some/dir/without/final/slash"));
            fail();
        } catch (IllegalArgumentException x) {/* right */}
        try {
            File f = new File(getWorkDir(),"test.jar");
            f.createNewFile();
            ClassPathSupport.createClassPath(new URL(BaseUtilities.toURI(f).toString() + '/'));
            fail();
        } catch (IllegalArgumentException x) {/* right */}
    }
    
    public void testEntryGetRoot() throws Exception {
        final File wd = getWorkDir();
        final FileObject root = FileUtil.createFolder(new File(wd,"root"));
        final ClassPath cp = ClassPathSupport.createClassPath(root);
        final ClassPath.Entry entry = cp.entries().iterator().next();
        entry.isDataResult.set(Boolean.TRUE);
        final FileObject fo = entry.getRoot();
        assertNotNull(fo);
        assertEquals(root, fo);
    }

    public void testEquality() throws Exception {
        assertTrue(ClassPath.EMPTY.equals(ClassPath.EMPTY));
        assertFalse(ClassPath.EMPTY.equals(ClassPathSupport.createClassPath(new URL[0])));
        assertFalse(ClassPathSupport.createClassPath(new URL[0]).equals(ClassPathSupport.createClassPath(new URL[0]))); // TBD; could revisit
        class Custom implements ClassPathImplementation {
            @Override public List<? extends PathResourceImplementation> getResources() {
                return Collections.emptyList();
            }
            @Override public void addPropertyChangeListener(PropertyChangeListener listener) {}
            @Override public void removePropertyChangeListener(PropertyChangeListener listener) {}
            @Override public boolean equals(Object obj) {
                return obj instanceof Custom;
            }
            @Override public int hashCode() {
                return 0;
            }
        }
        ClassPathImplementation cpi = new Custom();
        assertTrue(ClassPathFactory.createClassPath(cpi).equals(ClassPathFactory.createClassPath(cpi)));
        assertTrue(ClassPathFactory.createClassPath(cpi).equals(ClassPathFactory.createClassPath(new Custom())));
        assertFalse(ClassPathFactory.createClassPath(cpi).equals(ClassPathSupport.createClassPath(new URL[0])));
    }

    public void testDataRoot () throws Exception {
        final File wd = getWorkDir();
        final ClassPath cp = ClassPathSupport.createClassPath(
                new URL(wd.toURI().toURL().toExternalForm()+"test1/"),    //NOI18N
                new URL(wd.toURI().toURL().toExternalForm()+"test2/")    //NOI18N
        );
        final FileObject test1 = FileUtil.createData(FileUtil.toFileObject(wd), "test1");   //NOI18N
        final FileObject test2 = FileUtil.createFolder(FileUtil.toFileObject(wd), "test2");   //NOI18N
        assertEquals(Collections.singletonList(test2),Arrays.asList(cp.getRoots()));
    }

    public void testGC() throws Exception {
        final FileObject wd = FileUtil.toFileObject(FileUtil.normalizeFile(getWorkDir()));
        final FileObject root1 = FileUtil.createFolder(wd, "src1"); //NOI18N
        assertNotNull(root1);
        FileObject root2 = FileUtil.createFolder(wd, "src2"); //NOI18N
        assertNotNull(root2);
        final MockPropertyChangeListener l = new MockPropertyChangeListener(ClassPath.PROP_ROOTS);
        ClassPath cp = ClassPathSupport.createClassPath(root1, root2);
        cp.addPropertyChangeListener(l);
        assertNotNull(cp);
        FileObject[] roots = cp.getRoots();
        assertEquals(2, roots.length);
        assertEquals(root1, roots[0]);
        assertEquals(root2, roots[1]);
        root2.delete();
        l.assertEventCount(1);
        roots = cp.getRoots();
        assertEquals(1, roots.length);
        assertEquals(root1, roots[0]);
        root2 = FileUtil.createFolder(wd, "src2"); //NOI18N
        l.assertEventCount(1);
        roots = cp.getRoots();
        assertEquals(2, roots.length);
        assertEquals(root1, roots[0]);
        assertEquals(root2, roots[1]);
        final Reference<ClassPath> cpRef = new WeakReference<>(cp);
        cp = null;
        assertGC("ClassPath freed", cpRef);
    }

}
