String manifest = (String)props.get("manifest"); // NOI18N

                    File manifestFile = manifest == null ? null : findJarByName(manifest, cnb);

    public void testAddNewModuleExternalViaXML() throws Exception {

        mgr.mutexPrivileged().enterWriteAccess();

        try {

            assertEquals(Collections.emptySet(), list.readInitial());

            assertEquals(Collections.emptySet(), mgr.getModules());

            list.trigger(Collections.<Module>emptySet());

            assertEquals(Collections.emptySet(), mgr.getModules());

        } finally {

            mgr.mutexPrivileged().exitWriteAccess();

        }

        LoggedPCListener listener = new LoggedPCListener();

        mgr.addPropertyChangeListener(listener);

        modulesfolder.getFileSystem().runAtomicAction(new FileSystem.AtomicAction() {

            public void run() throws IOException {

                // XXX this will require that there be an appropriate InstalledFileLocator in Lookup

                FileObject fooxml = modulesfolder.createData("org-foo", "xml");

                copy(new File(JARS, "org-foo.xml"), fooxml);

                FileObject barxml = modulesfolder.createData("org-bar", "xml");

                File mf2 = new File(JARS, "depends-on-simple-module.mf");

                String xml = 

"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +

"<!DOCTYPE module PUBLIC \"-//NetBeans//DTD Module Status 1.0//EN\"\n" +

"                        \"http://www.netbeans.org/dtds/module-status-1_0.dtd\">\n" +

"<module name=\"org.bar\">\n" +

"    <param name=\"autoload\">false</param>\n" +

"    <param name=\"eager\">false</param>\n" +

"    <param name=\"enabled\">true</param>\n" +

"    <param name=\"jar\">" + new File(JARS, "depends-on-simple-module-external.jar") + "</param>\n" +

"    <param name=\"manifest\">" + mf2 + "</param>\n" +

"    <param name=\"release\">1</param>\n" +

"    <param name=\"reloadable\">false</param>\n" +

"</module>\n";

                OutputStream os = barxml.getOutputStream();

                os.write(xml.getBytes("UTF-8"));

                os.close();

            }

        });

        assertTrue("PROP_MODULES fired", listener.waitForChange(mgr, ModuleManager.PROP_MODULES));

        mgr.mutexPrivileged().enterReadAccess();

        try {

            Set modules = mgr.getEnabledModules();

            assertEquals(2, modules.size());

            TreeSet<String> names = new TreeSet<String>();

            {

                Iterator it  = modules.iterator();

                Module m = (Module)it.next();

                names.add(m.getCodeNameBase());

                assertTrue(m.isEnabled());

                m = (Module)it.next();

                assertTrue(m.isEnabled());

                names.add(m.getCodeNameBase());

            }

            Iterator<String> it = names.iterator();

            assertEquals("org.bar", it.next());

            assertEquals("org.foo", it.next());

            Class<?> clazz = mgr.getClassLoader().loadClass("org.bar.SomethingElse");

            Class<?> supr = clazz.getSuperclass();

            assertEquals("Parent is loaded from other module", "org.foo.Something", supr.getName());

        } finally {

            mgr.mutexPrivileged().exitReadAccess();

        }

    }

            Module m1 = mgr.create(new File(jars, "simple-module.jar"), null, false, false, false);

            assertEquals("org.foo", m1.getCodeNameBase());

            assertEquals("org.bar", m2.getCodeNameBase());

            assertEquals(Collections.EMPTY_SET, m1.getDependencies());

            assertEquals(Dependency.create(Dependency.TYPE_MODULE, "org.foo/1"), m2.getDependencies());

            Map<String,Module> modulesByName = new HashMap<String,Module>();

            modulesByName.put(m1.getCodeNameBase(), m1);

            modulesByName.put(m2.getCodeNameBase(), m2);

            List<Module> m1m2 = Arrays.asList(m1, m2);

            List<Module> m2m1 = Arrays.asList(m2, m1);

            Map<Module,List<Module>> deps = Util.moduleDependencies(m1m2, modulesByName, Collections.<String,Set<Module>>emptyMap());

            assertNull(deps.get(m1));

            assertEquals(Collections.singletonList(m1), deps.get(m2));

            assertEquals(m2m1, Utilities.topologicalSort(m1m2, deps));

            assertEquals(m2m1, Utilities.topologicalSort(m2m1, deps));

            // Leave commented out since it has a (hopefully clean) mutation effect

            // and could affect results:

            /*

            assertEquals(Collections.EMPTY_SET, m1.getProblems());

            assertEquals(Collections.EMPTY_SET, m2.getProblems());

             */

            Set<Module> m1PlusM2 = new HashSet<Module>();

            m1PlusM2.add(m1);

            m1PlusM2.add(m2);

            List<Module> toEnable = mgr.simulateEnable(m1PlusM2);

            assertEquals("correct result of simulateEnable", Arrays.asList(m1, m2), toEnable);

            mgr.enable(m1PlusM2);

            assertEquals(Arrays.asList(

                "prepare",

                "prepare",

                "load"

            ), installer.actions);

            assertEquals(Arrays.asList(

                m1,

                m2,

                Arrays.asList(m1, m2)

            ), installer.args);

            Class somethingelse = Class.forName("org.bar.SomethingElse", true, m2.getClassLoader());

            Method somemethod = somethingelse.getMethod("message");

            assertEquals("hello", somemethod.invoke(somethingelse.newInstance()));

            installer.clear();

            List<Module> toDisable = mgr.simulateDisable(Collections.singleton(m1));

            assertEquals("correct result of simulateDisable", Arrays.asList(m2, m1), toDisable);

            toDisable = mgr.simulateDisable(m1PlusM2);

            assertEquals("correct result of simulateDisable #2", Arrays.asList(m2, m1), toDisable);

            mgr.disable(m1PlusM2);

            assertFalse(m1.isEnabled());

            assertFalse(m2.isEnabled());

            assertEquals(Collections.EMPTY_SET, mgr.getEnabledModules());

            assertEquals(m1PlusM2, mgr.getModules());

            assertEquals(Arrays.asList(

                "unload",

                "dispose",

                "dispose"

            ), installer.actions);

            assertEquals(Arrays.asList(

                Arrays.asList(m2, m1),

                m2,

                m1

            ), installer.args);

            installer.clear();

            mgr.enable(m1);

            mgr.shutDown();

            assertEquals(Arrays.asList(

                "prepare",

                "load",

                "closing",

                "close"

            ), installer.actions);

            assertEquals(Arrays.asList(

                m1,

                Collections.singletonList(m1),

                Collections.singletonList(m1),

                Collections.singletonList(m1)

            ), installer.args);

        } finally {

            mgr.mutexPrivileged().exitWriteAccess();

        }

    }

    /** Load simple-module and depends-on-simple-module.

     * Make sure they can be installed and in a sane order.

     * Make sure a class from one can depend on a class from another.

     * Try to disable them too.

     */

    public void testSimpleInstallationOfExternalModule() throws Exception {

        FakeModuleInstaller installer = new FakeModuleInstaller();

        FakeEvents ev = new FakeEvents();

        ModuleManager mgr = new ModuleManager(installer, ev);

        mgr.mutexPrivileged().enterWriteAccess();

        try {

            File mf2 = new File(jars, "depends-on-simple-module.mf");

            assertTrue("mf2", mf2.exists());

            Module m2 = mgr.create(mf2, new File(jars, "depends-on-simple-module-external.jar"), null, false, false, false);

        <jar manifest="jars/simple-module.mf" compress="false" jarfile="jars/depends-on-simple-module-external.jar">

            <fileset dir="jars/depends-on-simple-module">

                <exclude name="**/*.java"/>

                <exclude name="**/*.nbattrs"/>

            </fileset>

        </jar>

    /**

     * This method creates a "standard" module with external manifest.

     * @see StandardModule

     * @since 2.14

     */

    public Module create(File manifest, File jar, Object history, boolean reloadable,

            boolean autoload, boolean eager, ModuleManager mgr, Events ev)

            throws IOException {

        return new StandardModule(mgr, ev, manifest, jar, history, reloadable, autoload, eager);

    }

        return create(null, jar, history, reloadable, autoload, eager);

    }

    /** Create a module from a JAR and external manifest add it to the managed set.

     * Will initially be disabled, unless it is eager and can

     * be enabled immediately.

     * May throw an IOException if the JAR file cannot be opened

     * for some reason, or is malformed.

     * If there is already a module of the same name managed,

     * throws a duplicate exception. In this case you may wish

     * to delete the original and try again.

     * You must give it some history object which can be used

     * to provide context for where the module came from and

     * whether it has been here before.

     * You cannot request that a module be both autoload and eager.

     * 

     * @since 2.14

     */

    public Module create(File manifest, File jar, Object history, boolean reloadable, boolean autoload, boolean eager) throws IOException, DuplicateException {

        } else {

            m = moduleFactory.create(

                manifest, jar.getAbsoluteFile(), 

                history, reloadable, autoload, eager, 

                this, ev

            );

        }

import java.io.FileInputStream;

    /** External module with manifest */

    StandardModule(ModuleManager mgr, Events ev, File manifest, File jar, Object history, boolean reloadable, boolean autoload, boolean eager) throws IOException {

        super(mgr, ev, history, reloadable, autoload, eager);

        this.jar = jar;

        FileInputStream is = new FileInputStream(manifest);

        this.manifest = new Manifest(is);

        is.close();

        parseManifest();

        findExtensionsAndVariants(this.manifest);

        // Check if some other module already listed this one in Class-Path.

        // For the chronologically reverse case, see findExtensionsAndVariants().

        Set<File> bogoOwners = extensionOwners.get(jar);

        if (bogoOwners != null) {

            Util.err.warning("module " + jar + " was incorrectly placed in the Class-Path of other JARs " + bogoOwners + "; please use OpenIDE-Module-Module-Dependencies instead");

        }

        moduleJARs.add(jar);

    }