<change id="non-projects">

            <api name="general"/>

            <summary>Support for more easily replaceable projects</summary>

            <version major="1" minor="15"/>

            <date day="17" month="1" year="2008"/>

            <author login="jtulach"/>

            <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible">

            </compatibility>

            <description>

	        <p>

                <code>ProjectManager.clearNonProjectCache()</code> now discards

                also projects which are named in a special way. If their class name

                contains <code>NonProject</code>, then they are freed from the cache.

            </p>

            </description>

            <class package="org.netbeans.api.project" name="ProjectManager"/>

            <issue number="124975"/>

        </change>

import java.util.Map.Entry;

     * <p>

     * Since version 1.15, this method also discards

     * projects which are named in a special way. If their class name

     * contains <code>NonProject</code>, then they are freed from the cache.

            // clearing every project that is marked as NonProject

            Iterator<Entry<FileObject, Union2<Reference<Project>, LoadStatus>>> it = dir2Proj.entrySet().iterator();

            while (it.hasNext()) {

                Union2<Reference<Project>, LoadStatus> union = it.next().getValue();

                if (union.hasFirst()) {

                    Reference<Project> ref = union.first();

                    Project prj = ref.get();

                    if (prj == null || prj.getClass().getSimpleName().indexOf("NonProject") == -1) { // NOI18N

                        continue;

                    }

                    it.remove();

                }

            }

import org.netbeans.junit.MockServices;

import org.netbeans.spi.project.ProjectFactory;

import org.netbeans.spi.project.ProjectState;

import org.openide.util.Lookup;

    }

    public static final class NonProjectFactory implements ProjectFactory {

        static FileObject recognize;

        public boolean isProject(FileObject projectDirectory) {

            return projectDirectory.equals(recognize);

        }

        public Project loadProject(FileObject projectDirectory, ProjectState state) throws IOException {

            if (isProject(projectDirectory)) {

                recognize = null;

                return new MyNonProject(projectDirectory);

            }

            return null;

        }

        public void saveProject(Project project) throws IOException, ClassCastException {

        }

    }

    static final class MyNonProject implements Project {

        FileObject dir;

        public MyNonProject(FileObject dir) {

            this.dir = dir;

        }

        public FileObject getProjectDirectory() {

            return dir;

        }

        public Lookup getLookup() {

            return Lookup.EMPTY;

        }

    }

    public void testProjectCanBeGCedWhenItContainsNameNonProject() throws Exception {

        MockLookup.setInstances(new NonProjectFactory(), TestUtil.testProjectFactory());

        Project prev = null;

        NonProjectFactory.recognize = goodproject;

        prev = pm.findProject(goodproject);

        assertNotNull("Project recognized", prev);

        assertEquals(MyNonProject.class, prev.getClass());

        pm.clearNonProjectCache();

        Project p = pm.findProject(goodproject);

        assertNotNull("Should have recognized goodproject", p);

        assertEquals("ProjectFactory was called once so far on goodproject", 1, TestUtil.projectLoadCount(goodproject));

        Reference<?> weak = new WeakReference<Object>(prev);

        prev = null;

        assertGC("NonProject can disappear", weak);

        // continue the normal test

        p = null;

        testFindProjectGC();