/** temp copy JARs which ought to be deleted */

    private Set deadJars = null; // Set<JarFile>

    /** Try to release any JAR locks held by this classloader.

     * @see #21114

     */

    void releaseLocks() {

        if (deadJars != null) throw new IllegalStateException();

        deadJars = new HashSet(); // Set<JarFile>

        try {

            for (int i = 0; i < sources.length; i++) {

                if (sources[i] instanceof JarFile) {

                    JarFile origJar = (JarFile)sources[i];

                    File orig = new File(origJar.getName());

                    String name = orig.getName();

                    String prefix, suffix;

                    int idx = name.lastIndexOf('.');

                    if (idx == -1) {

                        prefix = name;

                        suffix = null;

                    } else {

                        prefix = name.substring(0, idx);

                        suffix = name.substring(idx);

                    }

                    while (prefix.length() < 3) prefix += "x"; // NOI18N

                    File temp = File.createTempFile(prefix, suffix);

                    temp.deleteOnExit();

                    InputStream is = new FileInputStream(orig);

                    try {

                        OutputStream os = new FileOutputStream(temp);

                        try {

                            byte[] buf = new byte[4096];

                            int j;

                            while ((j = is.read(buf)) != -1) {

                                os.write(buf, 0, j);

                            }

                        } finally {

                            os.close();

                        }

                    } finally {

                        is.close();

                    }

                    JarFile tempJar = new JarFile(temp);

                    origJar.close();

                    deadJars.add(tempJar);

                    sources[i] = tempJar;

                    Util.err.log("#21114: replacing " + orig + " with " + temp);

                }

            }

        } catch (IOException ioe) {

            Util.err.notify(ErrorManager.INFORMATIONAL, ioe);

        }

    }

    /** Delete any temporary JARs we were holding on to.

     * Also close any other JARs in our list.

     */

    protected void finalize() throws Throwable {

        super.finalize();

        if (deadJars != null) {

            Iterator it = deadJars.iterator();

            while (it.hasNext()) {

                JarFile jar = (JarFile)it.next();

                jar.close();

                new File(jar.getName()).delete();

                Util.err.log("#21114: closing and deleting temporary " + jar.getName());

            }

        }

        for (int i = 0; i < sources.length; i++) {

            if (sources[i] instanceof JarFile) {

                ((JarFile)sources[i]).close();

            }

        }

    }

import org.openide.util.WeakSet;

    /** module classloaders that might have been created before */

    private final Set oldClassLoaders = new WeakSet(5); // Set<OneModuleClassLoader>

        oldClassLoaders.add(classloader);

    }

    /** Notify the module that it is being deleted. */

    void destroy() {

        // #21114: try to release all JAR locks

        Iterator it = oldClassLoaders.iterator();

        while (it.hasNext()) {

            OneModuleClassLoader l = (OneModuleClassLoader)it.next();

            if (!Boolean.getBoolean("no21114"))//XXX

            l.releaseLocks();

        }

        m.destroy();

        // In case run standalone, need a work dir.

        if (System.getProperty("nbjunit.workdir") == null) {

            // Hope java.io.tmpdir is set...

            System.setProperty("nbjunit.workdir", System.getProperty("java.io.tmpdir"));

        }

        } finally {

            mgr.mutexPrivileged().exitWriteAccess();

        }

    }

    /** Test #21114: after deleting a module, its JARs are released.

     * Would probably always pass on Unix, but on Windows it matters.

     */

    public void testModuleDeletion() throws Exception {

        FakeModuleInstaller installer = new FakeModuleInstaller();

        FakeEvents ev = new FakeEvents();

        ModuleManager mgr = new ModuleManager(installer, ev);

        mgr.mutexPrivileged().enterWriteAccess();

        try {

            File jar = new File(getWorkDir(), "copy-of-simple-module.jar");

            copy(new File(jars, "simple-module.jar"), jar);

            Module m = mgr.create(jar, null, false, false, false);

            mgr.enable(m);

            Class c = m.getClassLoader().loadClass("org.foo.Something");

            URL u = m.getClassLoader().getResource("org/foo/Something.class");

            URLConnection uc = u.openConnection();

            assertTrue("using JarURLConnection", uc instanceof JarURLConnection);

            uc.connect();

            mgr.disable(m);

            mgr.delete(m);

            assertTrue("could delete JAR file", jar.delete());

            c = null;

            u = null;

            uc = null;

            System.gc();

            System.runFinalization();

    void destroy() {}