Attachment #57212 for bug #128339

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 128339
Collapse All | Expand All





    private static final Logger LOGGER = Logger.getLogger(ProxyClassLoader.class.getName());
    private static final boolean LOG_LOADING;
    private static final ClassLoader TOP_CL = MainImpl.class.getClassLoader();

    static {
        boolean prop1 = System.getProperty("org.netbeans.ProxyClassLoader.level") != null;

    private final boolean transitive;

    /** The base class loader that is before all ProxyClassLoaders. */
    private ClassLoader systemCL = TOP_CL;
 
    /** A shared map of all packages known by all classloaders. Also covers META-INF based resources.
     * It contains two kinds of keys: dot-separated package names and slash-separated

     *                   automatically search through its parent list
     */
    public ProxyClassLoader(ClassLoader[] parents, boolean transitive) {
        super(TOP_CL);
        this.transitive = transitive;
        
        this.parents = coalesceParents(parents);




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 * 
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 * 
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 * 
 * Contributor(s):
 * 
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.netbeans.junit;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.List;
import junit.framework.Assert;
import junit.framework.TestCase;
import junit.framework.TestResult;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;

/**
 *
 * @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
 */
public class NbModuleSuite extends NbTestSuite {
    private Class<?> clazz;

    public NbModuleSuite(Class<?> aClass) {
        super();
        clazz = aClass;
    }

    @Override
    public void run(TestResult result) {
        try {
            runInRuntimeContainer(result);
        } catch (Exception ex) {
            result.addError(this, ex);
        }
    }
    
    private void runInRuntimeContainer(TestResult result) throws Exception {
        File platform = findPlatform();
        File[] boot = new File(platform, "lib").listFiles();
        List<URL> bootCP = new ArrayList<URL>();
        for (int i = 0; i < boot.length; i++) {
            URL u = boot[i].toURL();
            if (u.toExternalForm().endsWith(".jar")) {
                bootCP.add(u);
            }
        }
        // loader that does not see our current classloader
        ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();
        Assert.assertNotNull("Parent", parent);
        URLClassLoader loader = new URLClassLoader(bootCP.toArray(new URL[0]), parent);
        Class<?> main = loader.loadClass("org.netbeans.Main"); // NOI18N
        Assert.assertEquals("Loaded by our classloader", loader, main.getClassLoader());
        Method m = main.getDeclaredMethod("main", String[].class); // NOI18N
        
        System.setProperty("java.util.logging.config", "-");
        System.setProperty("netbeans.home", platform.getPath());
        
        File ud = new File(new File(Manager.getWorkDirPath()), "userdir");
        ud.mkdirs();
        NbTestCase.deleteSubFiles(ud);
        
        System.setProperty("netbeans.user", ud.getPath());
        
        List<String> args = new ArrayList<String>();
        args.add("--nosplash");
        m.invoke(null, (Object)args.toArray(new String[0]));
        
        ClassLoader global = Lookup.getDefault().lookup(ClassLoader.class);
        Assert.assertNotNull("Global classloader is initialized", global);
        
        URL[] testCP = preparePath(clazz);
        JunitLoader testLoader = new JunitLoader(testCP, global, NbTestSuite.class.getClassLoader());
        Class<?> sndClazz = testLoader.loadClass(clazz.getName());

        new NbTestSuite(sndClazz).run(result);
    }
    
    private URL[] preparePath(Class<?>... classes) {
        Collection<URL> cp = new LinkedHashSet<URL>();
        for (Class c : classes) {
            URL test = c.getProtectionDomain().getCodeSource().getLocation();
            Assert.assertNotNull("URL found for " + c, test);
            cp.add(test);
        }
        return cp.toArray(new URL[0]);
    }

    
    private File findPlatform() {
        try {
            File util = new File(Lookup.class.getProtectionDomain().getCodeSource().getLocation().toURI());
            Assert.assertTrue("Util exists: " + util, util.exists());

            return util.getParentFile().getParentFile();
        } catch (URISyntaxException ex) {
            Assert.fail("Cannot find utilities JAR");
            return null;
        }
    }
    
    private static final class JunitLoader extends URLClassLoader {
        private final ClassLoader junit;

        public JunitLoader(URL[] urls, ClassLoader parent, ClassLoader junit) {
            super(urls, parent);
            this.junit = junit;
        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            if (isUnit(name)) {
                return junit.loadClass(name);
            }
            return super.findClass(name);
        }

        @Override
        public URL findResource(String name) {
            if (isUnit(name)) {
                return junit.getResource(name);
            }
            return super.findResource(name);
        }

        @Override
        public Enumeration<URL> findResources(String name) throws IOException {
            if (isUnit(name)) {
                return junit.getResources(name);
            }
            return super.findResources(name);
        }
        
        private final boolean isUnit(String res) {
            if (res.startsWith("junit")) {
                return true;
            }
            if (res.startsWith("org.junit") || res.startsWith("org/junit")) {
                return true;
            }
            if (res.startsWith("org.netbeans.junit") || res.startsWith("org/netbeans/junit")) {
                return true;
            }
            return false;
        }
    }
}

Lines 732-738 public abstract class NbTestCase extends Link Here

(-)a/nbjunit/src/org/netbeans/junit/NbTestCase.java (-2 / +2 lines)
732	}	732	}
733		733
734	// private method for deleting a file/directory (and all its subdirectories/files)	734	// private method for deleting a file/directory (and all its subdirectories/files)
735	private void deleteFile(File file) throws IOException {	735	private static void deleteFile(File file) throws IOException {
736	if (file.isDirectory()) {	736	if (file.isDirectory()) {
737	// file is a directory - delete sub files first	737	// file is a directory - delete sub files first
738	File files[] = file.listFiles();	738	File files[] = file.listFiles();
Lines 750-756 public abstract class NbTestCase extends Link Here
750	}	750	}
751		751
752	// private method for deleting every subfiles/subdirectories of a file object	752	// private method for deleting every subfiles/subdirectories of a file object
753	private void deleteSubFiles(File file) throws IOException {	753	static void deleteSubFiles(File file) throws IOException {
754	if (file.isDirectory()) {	754	if (file.isDirectory()) {
755	File files[] = file.listFiles();	755	File files[] = file.listFiles();
756	for (int i = 0; i < files.length; i++) {	756	for (int i = 0; i < files.length; i++) {




package org.netbeans.junit;

import junit.framework.TestCase;

public class NbModuleSuiteHelper extends TestCase {
    static {
        System.err.println("here");
    }

    public NbModuleSuiteHelper(String t) {
        super(t);
    }

    public void testOne() {
        System.setProperty("t.one", "OK");
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 * 
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 * 
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 * 
 * Contributor(s):
 * 
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.netbeans.junit;

import junit.framework.TestCase;
import junit.framework.TestResult;

/**
 *
 * @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
 */
public class NbModuleSuiteTest extends TestCase {
    
    public NbModuleSuiteTest(String testName) {
        super(testName);
    }            

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

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

    /**
     * Test of run method, of class NbModuleSuite.
     */
    public void testRun() {
        NbModuleSuite instance = new NbModuleSuite(NbModuleSuiteHelper.class);
        junit.textui.TestRunner.run(instance);
        
        assertEquals("OK", System.getProperty("t.one"));
    }
}




package org.netbeans.junit;

import junit.framework.TestCase;

public class NbModuleSuiteHelper extends TestCase {
    static {
        System.err.println("here");
    }

    public NbModuleSuiteHelper(String t) {
        super(t);
    }

    public void testOne() {
        System.setProperty("t.one", "OK");
    }
}




     * Test of run method, of class NbModuleSuite.
     */
    public void testRun() {
        NbModuleSuite instance = new NbModuleSuite(T.class);
        junit.textui.TestRunner.run(instance);
        
        assertEquals("OK", System.getProperty("t.one"));
    }
    
    public static class T extends TestCase {
        public T(String t) {
            super(t);
        }

        public void testOne() {
            System.setProperty("t.one", "OK");
        }
    }
    
}

Lines 40-46 package org.netbeans.junit; Link Here

(-)a/nbjunit/src/org/netbeans/junit/NbModuleSuite.java (+88 lines)
40	package org.netbeans.junit;	40	package org.netbeans.junit;
41		41
42	import java.io.File;	42	import java.io.File;
		43	import java.io.FileInputStream;
		44	import java.io.FileOutputStream;
43	import java.io.IOException;	45	import java.io.IOException;
		46	import java.io.InputStream;
44	import java.lang.reflect.Method;	47	import java.lang.reflect.Method;
45	import java.net.MalformedURLException;	48	import java.net.MalformedURLException;
46	import java.net.URISyntaxException;	49	import java.net.URISyntaxException;
Lines 49-56 import java.util.ArrayList; Link Here
49	import java.util.ArrayList;	52	import java.util.ArrayList;
50	import java.util.Collection;	53	import java.util.Collection;
51	import java.util.Enumeration;	54	import java.util.Enumeration;
		55	import java.util.HashSet;
52	import java.util.LinkedHashSet;	56	import java.util.LinkedHashSet;
53	import java.util.List;	57	import java.util.List;
		58	import java.util.Set;
		59	import java.util.TreeSet;
		60	import java.util.regex.Matcher;
		61	import java.util.regex.Pattern;
54	import junit.framework.Assert;	62	import junit.framework.Assert;
55	import junit.framework.TestCase;	63	import junit.framework.TestCase;
56	import junit.framework.TestResult;	64	import junit.framework.TestResult;
Lines 105-110 public class NbModuleSuite extends NbTes Link Here
105		113
106	System.setProperty("netbeans.user", ud.getPath());	114	System.setProperty("netbeans.user", ud.getPath());
107		115
		116	TreeSet<String> modules = new TreeSet<String>();
		117	modules.addAll(findEnabledModules(NbTestSuite.class.getClassLoader()));
		118	modules.add("org.openide.filesystems");
		119	modules.add("org.openide.modules");
		120	modules.add("org.openide.util");
		121	modules.add("org.netbeans.core.startup");
		122	modules.add("org.netbeans");
		123	turnModules(ud, modules, platform);
		124
108	List<String> args = new ArrayList<String>();	125	List<String> args = new ArrayList<String>();
109	args.add("--nosplash");	126	args.add("--nosplash");
110	m.invoke(null, (Object)args.toArray(new String[0]));	127	m.invoke(null, (Object)args.toArray(new String[0]));
Lines 140-145 public class NbModuleSuite extends NbTes Link Here
140	Assert.fail("Cannot find utilities JAR");	157	Assert.fail("Cannot find utilities JAR");
141	return null;	158	return null;
142	}	159	}
		160	}
		161
		162	private static Pattern CODENAME = Pattern.compile("OpenIDE-Module: ([^/$ \n\r])[/]?[0-9]*", Pattern.MULTILINE);
		163	/** Looks for all modules on classpath of given loader and builds
		164	* their list from them.
		165	*/
		166	static Set<String> findEnabledModules(ClassLoader loader) throws IOException {
		167	Set<String> cnbs = new TreeSet<String>();
		168
		169	Enumeration<URL> en = loader.getResources("META-INF/MANIFEST.MF");
		170	while (en.hasMoreElements()) {
		171	URL url = en.nextElement();
		172	String manifest = asString(url.openStream(), true);
		173	Matcher m = CODENAME.matcher(manifest);
		174	if (m.find()) {
		175	cnbs.add(m.group(1));
		176	}
		177	}
		178
		179	return cnbs;
		180	}
		181
		182	private static String asString(InputStream is, boolean close) throws IOException {
		183	byte[] arr = new byte[is.available()];
		184	int len = is.read(arr);
		185	if (len != arr.length) {
		186	throw new IOException("Not fully read: " + arr.length + " was " + len);
		187	}
		188	if (close) {
		189	is.close();
		190	}
		191	return new String(arr, "UTF-8"); // NOI18N
143	}	192	}
144		193
145	private static final class JunitLoader extends URLClassLoader {	194	private static final class JunitLoader extends URLClassLoader {
Lines 187-190 public class NbModuleSuite extends NbTes Link Here
187	return false;	236	return false;
188	}	237	}
189	}	238	}
		239
		240	private static Pattern ENABLED = Pattern.compile("<param name=[\"']enabled[\"']>([^<]*)</param>", Pattern.MULTILINE);
		241
		242	private static void turnModules(File ud, TreeSet<String> modules, File... clusterDirs) throws IOException {
		243	File config = new File(new File(ud, "config"), "Modules");
		244	config.mkdirs();
		245
		246	for (File c : clusterDirs) {
		247	File modulesDir = new File(new File(c, "config"), "Modules");
		248	for (File m : modulesDir.listFiles()) {
		249	String n = m.getName();
		250	if (n.endsWith(".xml")) {
		251	n = n.substring(0, n.length() - 4);
		252	}
		253	n = n.replace('-', '.');
		254
		255	String xml = asString(new FileInputStream(m), true);
		256	Matcher matcherEnabled = ENABLED.matcher(xml);
		257	// Matcher matcherEager = EAGER.matcher(xml);
		258
		259	boolean enabled = matcherEnabled.find() && "true".equals(matcherEnabled.group(1));
		260
		261	if (modules.contains(n) != enabled) {
		262	String out =
		263	xml.substring(0, matcherEnabled.start(1)) +
		264	(enabled ? "false" : "true") +
		265	xml.substring(matcherEnabled.end(1));
		266	writeModule(new File(config, m.getName()), out);
		267	}
		268	}
		269	}
		270	}
		271
		272	private static void writeModule(File file, String xml) throws IOException {
		273	FileOutputStream os = new FileOutputStream(file);
		274	os.write(xml.getBytes("UTF-8"));
		275	os.close();
		276	}
190	}	277	}
		278





package org.netbeans.junit;

import java.util.Set;
import junit.framework.TestCase;
import junit.framework.TestResult;


        assertEquals("OK", System.getProperty("t.one"));
    }
    
    public void testModulesForCL() throws Exception {
        Set<String> s = NbModuleSuite.findEnabledModules(ClassLoader.getSystemClassLoader());
        assertEquals("Three modules: " + s, 3, s.size());
        
        assertTrue("Util: " + s, s.contains("org.openide.util"));
        assertTrue("nbjunit: " + s, s.contains("org.netbeans.modules.nbjunit"));
        assertTrue("insanse: " + s, s.contains("org.netbeans.insane"));
    }
    
    public static class T extends TestCase {
        public T(String t) {
            super(t);




import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import junit.framework.Assert;
import junit.framework.TestCase;
import junit.framework.TestResult;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;

/**

 * @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
 */
public class NbModuleSuite extends NbTestSuite {
    private final Class<?> clazz;
    private final String clusterRegExp;

    public NbModuleSuite(Class<?> aClass) {
        this(aClass, ".*");
    }
    
    public NbModuleSuite(Class<?> aClass, String clusterRegExp) {
        super();
        this.clazz = aClass;
        this.clusterRegExp = clusterRegExp;
    }

    @Override

        modules.add("org.openide.filesystems");
        modules.add("org.openide.modules");
        modules.add("org.openide.util");
        modules.remove("org.netbeans.insane");
        modules.add("org.netbeans.core.startup");
        modules.add("org.netbeans.bootstrap");
        turnModules(ud, modules, platform);

        StringBuilder sb = new StringBuilder();
        String sep = "";
        for (File f : findClusters()) {
            turnModules(ud, modules, f);
            sb.append(sep);
            sb.append(f.getPath());
            sep = File.pathSeparator;
        }
        System.setProperty("netbeans.dirs", sb.toString());
        
        List<String> args = new ArrayList<String>();
        args.add("--nosplash");

            Assert.fail("Cannot find utilities JAR");
            return null;
        }
    }
    
    private File[] findClusters() {
        List<File> clusters = new ArrayList<File>();
        File plat = findPlatform();
        
        for (File f : plat.getParentFile().listFiles()) {
            if (f.equals(plat)) {
                continue;
            }
            if (!f.getName().matches(clusterRegExp)) {
                continue;
            }
            File m = new File(new File(f, "config"), "Modules");
            if (m.exists()) {
                clusters.add(f);
            }
        }
        return clusters.toArray(new File[0]);
    }
    
    private static Pattern CODENAME = Pattern.compile("OpenIDE-Module: *([^/$ \n\r]*)[/]?[0-9]*", Pattern.MULTILINE);

                boolean enabled = matcherEnabled.find() && "true".equals(matcherEnabled.group(1));
                
                if (modules.contains(n) != enabled) {
                    assert matcherEnabled.groupCount() == 1 : "Groups: " + matcherEnabled.groupCount() + " for:\n" + xml;

                    try {
                        String out = 
                            xml.substring(0, matcherEnabled.start(1)) +
                            (enabled ? "false" : "true") +
                            xml.substring(matcherEnabled.end(1));
                        writeModule(new File(config, m.getName()), out);
                    } catch (IllegalStateException ex) {
                        throw (IOException)new IOException("Unparseable:\n" + xml).initCause(ex);
                    }
                }
            }
        }

Lines 67-73 public class NbModuleSuiteTest extends T Link Here

(-)a/nbjunit/test/unit/src/org/netbeans/junit/NbModuleSuiteTest.java (-1 / +1 lines)
67	* Test of run method, of class NbModuleSuite.	67	* Test of run method, of class NbModuleSuite.
68	*/	68	*/
69	public void testRun() {	69	public void testRun() {
70	NbModuleSuite instance = new NbModuleSuite(T.class);	70	NbModuleSuite instance = new NbModuleSuite(T.class, "");
71	junit.textui.TestRunner.run(instance);	71	junit.textui.TestRunner.run(instance);
72		72
73	assertEquals("OK", System.getProperty("t.one"));	73	assertEquals("OK", System.getProperty("t.one"));




    <!-- ACTUAL CHANGES BEGIN HERE: -->

<changes>
    <change id="NbModuleSuite">
        <api name="nbjunit"/>
        <summary>Support class to allow excution of unit tests inside of NetBeans Runtime Container</summary>
        <version major="1" minor="46"/>
        <date day="29" month="2" year="2008"/>
        <author login="jtulach"/>
        <compatibility addition="yes"/>
        <description>
            <p>
                It always used to be hard to setup the right environment for test
                execution. In case this NetBeans this is even harder. The module
                system is ready to work without classpath isolation, however 
                not every feature is available and every behaviour stays the
                same. That is why there is now the new <code>NbModuleSuite</code>
                support class that allows to really start the whole NetBeans 
                Runtime Container, satisfy all the dependencies and only then 
                load the testing class and execute it.
            </p>
        </description>
        <class package="org.netbeans.junit" name="NbModuleSuite"/>
    </change>
    <change id="CollectData">
        <api name="nbjunit"/>
        <summary>Support for Garbage Collecting of Log Message Arguments</summary>
        <version major="1" minor="44"/>
        <date day="14" month="12" year="2007"/>
        <author login="jtulach"/>
        <compatibility addition="yes"/>
        <description>

Lines 2-5 OpenIDE-Module: org.netbeans.modules.nbj Link Here

(-)a/nbjunit/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.nbjunit/1	2	OpenIDE-Module: org.netbeans.modules.nbjunit/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/junit/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/junit/Bundle.properties
4	OpenIDE-Module-Layer: org/netbeans/junit/layer.xml	4	OpenIDE-Module-Layer: org/netbeans/junit/layer.xml
5	OpenIDE-Module-Specification-Version: 1.45	5	OpenIDE-Module-Specification-Version: 1.46




import java.util.regex.Matcher;
import java.util.regex.Pattern;
import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestResult;
import org.openide.util.Lookup;

/**
 * Wraps a test class with proper NetBeans Runtime Container environment.
 * This allows to execute tests in a very similar environment to the 
 * actual invocation in the NetBeans IDE. To use write your test as
 * you are used to and add suite static method:
 * <pre>
 * public class YourTest extends NbTestCase {
 *   public YourTest(String s) { super(s); }
 * 
 *   public static Test suite() {
 *     return NbModuleSuite.create(YourTest.class);
 *   }
 * 
 *   public void testXYZ() { ... }
 *   public void testABC() { ... }
 * }
 * </pre>
 *
 * @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
 */
public final class NbModuleSuite extends Object {
    private final Class<?> clazz;
    private final String clusterRegExp;

    /** Wraps the provided class into a test that set ups properly the
     * testing environment. The set of enabled modules is going to be
     * determined from the actual classpath of a module, which is common
     * when in all NetBeans tests. All other modules are kept disabled.
     * <p>
     * 
     * Warning: because the NetBeans Runtime Environment
     * plays various tricks with classloaders, the class provided as argument
     * is just a <quote>template</quote>, the one that will really be executed
     * is loaded by another classloader. As such it is not recommended to
     * do any static initializations in the class, as that would be run twice,
     * in different modes and could cause quite a big mishmash.
     * 
     * @param clazz the class with bunch of testXYZ methods
     * @return test that starts the NetBeans Runtime Container and then runs the 
     */
    public static Test create(Class<? extends Test> clazz) {
        return new S(clazz);
    }

    /** Factory method to create wrapper test that knows how to setup proper
     * NetBeans Runtime Container environment. In addition to other factory 
     * methods, it allows one limit the clusters that shall be made available.
     * For example <code>ide.*|java.*</code> will start the container just
     * with platform, ide and java clusters.
     * 
     * 
     * @param clazz the class with bunch of testXYZ methods
     * @param clustersRegExp regexp to apply to name of cluster to find out if it is supposed to be included
     *    in the runtime container setup or not
     * @return runtime container ready test
     */
    public static Test create(Class<? extends Test> clazz, String clustersRegExp) {
        return new S(clazz);
            URL u = boot[i].toURL();
            if (u.toExternalForm().endsWith(".jar")) {
                bootCP.add(u);
            }
        }
        // loader that does not see our current classloader
        ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();
        Assert.assertNotNull("Parent", parent);
        URLClassLoader loader = new URLClassLoader(bootCP.toArray(new URL[0]), parent);
        Class<?> main = loader.loadClass("org.netbeans.Main"); // NOI18N
        Assert.assertEquals("Loaded by our classloader", loader, main.getClassLoader());
        Method m = main.getDeclaredMethod("main", String[].class); // NOI18N
        
        System.setProperty("java.util.logging.config", "-");
        System.setProperty("netbeans.home", platform.getPath());
        
        File ud = new File(new File(Manager.getWorkDirPath()), "userdir");
        ud.mkdirs();
        NbTestCase.deleteSubFiles(ud);
        
        System.setProperty("netbeans.user", ud.getPath());
        
        TreeSet<String> modules = new TreeSet<String>();
        modules.addAll(findEnabledModules(NbTestSuite.class.getClassLoader()));
        modules.add("org.openide.filesystems");
        modules.add("org.openide.modules");
        modules.add("org.openide.util");
        modules.remove("org.netbeans.insane");
        modules.add("org.netbeans.core.startup");
        modules.add("org.netbeans.bootstrap");
        turnModules(ud, modules, platform);

        StringBuilder sb = new StringBuilder();
        String sep = "";
        for (File f : findClusters()) {
            turnModules(ud, modules, f);
            sb.append(sep);
            sb.append(f.getPath());
            sep = File.pathSeparator;
        }
        System.setProperty("netbeans.dirs", sb.toString());
        
        List<String> args = new ArrayList<String>();
        args.add("--nosplash");
        m.invoke(null, (Object)args.toArray(new String[0]));
        
        ClassLoader global = Lookup.getDefault().lookup(ClassLoader.class);
        Assert.assertNotNull("Global classloader is initialized", global);
        
        URL[] testCP = preparePath(clazz);
        JunitLoader testLoader = new JunitLoader(testCP, global, NbTestSuite.class.getClassLoader());
        Class<?> sndClazz = testLoader.loadClass(clazz.getName());

        new NbTestSuite(sndClazz).run(result);
    }
    
    private URL[] preparePath(Class<?>... classes) {
        Collection<URL> cp = new LinkedHashSet<URL>();
        for (Class c : classes) {
            URL test = c.getProtectionDomain().getCodeSource().getLocation();
            Assert.assertNotNull("URL found for " + c, test);
            cp.add(test);
        }
        return cp.toArray(new URL[0]);
    }

    static final class S extends NbTestSuite {
        private final Class<?> clazz;
        private final String clusterRegExp;
            File util = new File(Lookup.class.getProtectionDomain().getCodeSource().getLocation().toURI());
            Assert.assertTrue("Util exists: " + util, util.exists());

        public S(Class<?> aClass) {
            this(aClass, ".*");
            Assert.fail("Cannot find utilities JAR");
            return null;
        }

        public S(Class<?> aClass, String clusterRegExp) {
            super();
            this.clazz = aClass;
            this.clusterRegExp = clusterRegExp;
        
        for (File f : plat.getParentFile().listFiles()) {
            if (f.equals(plat)) {
                continue;
            }
            if (!f.getName().matches(clusterRegExp)) {
                continue;
            }
            File m = new File(new File(f, "config"), "Modules");
            if (m.exists()) {
                clusters.add(f);
            }
        }

        @Override
        public void run(TestResult result) {
            try {
                runInRuntimeContainer(result);
            } catch (Exception ex) {
                result.addError(this, ex);
    static Set<String> findEnabledModules(ClassLoader loader) throws IOException {
        Set<String> cnbs = new TreeSet<String>();
        
        Enumeration<URL> en = loader.getResources("META-INF/MANIFEST.MF");
        while (en.hasMoreElements()) {
            URL url = en.nextElement();
            String manifest = asString(url.openStream(), true);
            Matcher m = CODENAME.matcher(manifest);
            if (m.find()) {
                cnbs.add(m.group(1));
            }
        }

        private void runInRuntimeContainer(TestResult result) throws Exception {
            File platform = findPlatform();
            File[] boot = new File(platform, "lib").listFiles();
            List<URL> bootCP = new ArrayList<URL>();
            for (int i = 0; i < boot.length; i++) {
                URL u = boot[i].toURL();
                if (u.toExternalForm().endsWith(".jar")) {
                    bootCP.add(u);
                }
            }
            // loader that does not see our current classloader
            ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();
            Assert.assertNotNull("Parent", parent);
            URLClassLoader loader = new URLClassLoader(bootCP.toArray(new URL[0]), parent);
            Class<?> main = loader.loadClass("org.netbeans.Main"); // NOI18N
            Assert.assertEquals("Loaded by our classloader", loader, main.getClassLoader());
            Method m = main.getDeclaredMethod("main", String[].class); // NOI18N

            System.setProperty("java.util.logging.config", "-");
            System.setProperty("netbeans.home", platform.getPath());

            File ud = new File(new File(Manager.getWorkDirPath()), "userdir");
            ud.mkdirs();
            NbTestCase.deleteSubFiles(ud);

            System.setProperty("netbeans.user", ud.getPath());

            TreeSet<String> modules = new TreeSet<String>();
            modules.addAll(findEnabledModules(NbTestSuite.class.getClassLoader()));
            modules.add("org.openide.filesystems");
            modules.add("org.openide.modules");
            modules.add("org.openide.util");
            modules.remove("org.netbeans.insane");
            modules.add("org.netbeans.core.startup");
            modules.add("org.netbeans.bootstrap");
            turnModules(ud, modules, platform);

            StringBuilder sb = new StringBuilder();
            String sep = "";
            for (File f : findClusters()) {
                turnModules(ud, modules, f);
                sb.append(sep);
                sb.append(f.getPath());
                sep = File.pathSeparator;
            }
            System.setProperty("netbeans.dirs", sb.toString());

            List<String> args = new ArrayList<String>();
            args.add("--nosplash");
            m.invoke(null, (Object)args.toArray(new String[0]));

            ClassLoader global = Lookup.getDefault().lookup(ClassLoader.class);
            Assert.assertNotNull("Global classloader is initialized", global);

            URL[] testCP = preparePath(clazz);
            JunitLoader testLoader = new JunitLoader(testCP, global, NbTestSuite.class.getClassLoader());
            Class<?> sndClazz = testLoader.loadClass(clazz.getName());

            new NbTestSuite(sndClazz).run(result);
        }

        private URL[] preparePath(Class<?>... classes) {
            Collection<URL> cp = new LinkedHashSet<URL>();
            for (Class c : classes) {
                URL test = c.getProtectionDomain().getCodeSource().getLocation();
                Assert.assertNotNull("URL found for " + c, test);
                cp.add(test);
            }
            return cp.toArray(new URL[0]);
        }


        private File findPlatform() {
            try {
                File util = new File(Lookup.class.getProtectionDomain().getCodeSource().getLocation().toURI());
                Assert.assertTrue("Util exists: " + util, util.exists());

                return util.getParentFile().getParentFile();
            } catch (URISyntaxException ex) {
                Assert.fail("Cannot find utilities JAR");
                return null;
            }
            return super.findResource(name);
        }

        private File[] findClusters() {
            List<File> clusters = new ArrayList<File>();
            File plat = findPlatform();

            for (File f : plat.getParentFile().listFiles()) {
                if (f.equals(plat)) {
                    continue;
                }
                if (!f.getName().matches(clusterRegExp)) {
                    continue;
                }
                File m = new File(new File(f, "config"), "Modules");
                if (m.exists()) {
                    clusters.add(f);
                }
            }
            return clusters.toArray(new File[0]);
        }

        private static Pattern CODENAME = Pattern.compile("OpenIDE-Module: *([^/$ \n\r]*)[/]?[0-9]*", Pattern.MULTILINE);
        /** Looks for all modules on classpath of given loader and builds 
         * their list from them.
         */
        static Set<String> findEnabledModules(ClassLoader loader) throws IOException {
            Set<String> cnbs = new TreeSet<String>();

            Enumeration<URL> en = loader.getResources("META-INF/MANIFEST.MF");
            while (en.hasMoreElements()) {
                URL url = en.nextElement();
                String manifest = asString(url.openStream(), true);
                Matcher m = CODENAME.matcher(manifest);
                if (m.find()) {
                    cnbs.add(m.group(1));
                }
            }

            return cnbs;
        }

        private static String asString(InputStream is, boolean close) throws IOException {
            byte[] arr = new byte[is.available()];
            int len = is.read(arr);
            if (len != arr.length) {
                throw new IOException("Not fully read: " + arr.length + " was " + len);
            }
            if (close) {
                is.close();
            }
            return new String(arr, "UTF-8"); // NOI18N
        }
    }

        private static final class JunitLoader extends URLClassLoader {
            private final ClassLoader junit;

            public JunitLoader(URL[] urls, ClassLoader parent, ClassLoader junit) {
                super(urls, parent);
                this.junit = junit;
            }

            @Override
            protected Class<?> findClass(String name) throws ClassNotFoundException {
                if (isUnit(name)) {
                    return junit.loadClass(name);
                }
                return super.findClass(name);
            }
                String xml = asString(new FileInputStream(m), true);
                Matcher matcherEnabled = ENABLED.matcher(xml);
             //   Matcher matcherEager = EAGER.matcher(xml);
                
                boolean enabled = matcherEnabled.find() && "true".equals(matcherEnabled.group(1));
                
                if (modules.contains(n) != enabled) {
                    assert matcherEnabled.groupCount() == 1 : "Groups: " + matcherEnabled.groupCount() + " for:\n" + xml;

            @Override
            public URL findResource(String name) {
                if (isUnit(name)) {
                    return junit.getResource(name);
                }
                return super.findResource(name);
            }

            @Override
            public Enumeration<URL> findResources(String name) throws IOException {
                if (isUnit(name)) {
                    return junit.getResources(name);
                }
                return super.findResources(name);
            }

            private final boolean isUnit(String res) {
                if (res.startsWith("junit")) {
                    return true;
                }
                if (res.startsWith("org.junit") || res.startsWith("org/junit")) {
                    return true;
                }
                if (res.startsWith("org.netbeans.junit") || res.startsWith("org/netbeans/junit")) {
                    return true;
                }
                return false;
            }
        }

        private static Pattern ENABLED = Pattern.compile("<param name=[\"']enabled[\"']>([^<]*)</param>", Pattern.MULTILINE);

        private static void turnModules(File ud, TreeSet<String> modules, File... clusterDirs) throws IOException {
            File config = new File(new File(ud, "config"), "Modules");
            config.mkdirs();

            for (File c : clusterDirs) {
                File modulesDir = new File(new File(c, "config"), "Modules");
                for (File m : modulesDir.listFiles()) {
                    String n = m.getName();
                    if (n.endsWith(".xml")) {
                        n = n.substring(0, n.length() - 4);
                    }
                    n = n.replace('-', '.');

                    String xml = asString(new FileInputStream(m), true);
                    Matcher matcherEnabled = ENABLED.matcher(xml);
                 //   Matcher matcherEager = EAGER.matcher(xml);

                    boolean enabled = matcherEnabled.find() && "true".equals(matcherEnabled.group(1));

                    if (modules.contains(n) != enabled) {
                        assert matcherEnabled.groupCount() == 1 : "Groups: " + matcherEnabled.groupCount() + " for:\n" + xml;

                        try {
                            String out = 
                                xml.substring(0, matcherEnabled.start(1)) +
                                (enabled ? "false" : "true") +
                                xml.substring(matcherEnabled.end(1));
                            writeModule(new File(config, m.getName()), out);
                        } catch (IllegalStateException ex) {
                            throw (IOException)new IOException("Unparseable:\n" + xml).initCause(ex);
                        }
                    }
                }
            }
        }
    }

        private static void writeModule(File file, String xml) throws IOException {
            FileOutputStream os = new FileOutputStream(file);
            os.write(xml.getBytes("UTF-8"));
            os.close();
        }
    } // end of S
}





package org.netbeans.junit;

import java.util.Set;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;

/**
 *

     * Test of run method, of class NbModuleSuite.
     */
    public void testRun() {
        Test instance = NbModuleSuite.create(T.class, "");
        junit.textui.TestRunner.run(instance);
        
        assertEquals("OK", System.getProperty("t.one"));
    }
    
    public void testModulesForCL() throws Exception {
        Set<String> s = NbModuleSuite.S.findEnabledModules(ClassLoader.getSystemClassLoader());
        assertEquals("Three modules: " + s, 3, s.size());
        
        assertTrue("Util: " + s, s.contains("org.openide.util"));

Return to bug 128339

Lines 75-80 public class ProxyClassLoader extends Cl Link Here

(-)a/o.n.bootstrap/src/org/netbeans/ProxyClassLoader.java (-1 / +3 lines)
75		75
76	private static final Logger LOGGER = Logger.getLogger(ProxyClassLoader.class.getName());	76	private static final Logger LOGGER = Logger.getLogger(ProxyClassLoader.class.getName());
77	private static final boolean LOG_LOADING;	77	private static final boolean LOG_LOADING;
		78	private static final ClassLoader TOP_CL = MainImpl.class.getClassLoader();
78		79
79	static {	80	static {
80	boolean prop1 = System.getProperty("org.netbeans.ProxyClassLoader.level") != null;	81	boolean prop1 = System.getProperty("org.netbeans.ProxyClassLoader.level") != null;
Lines 90-96 public class ProxyClassLoader extends Cl Link Here
90	private final boolean transitive;	91	private final boolean transitive;
91		92
92	/** The base class loader that is before all ProxyClassLoaders. */	93	/** The base class loader that is before all ProxyClassLoaders. */
93	private ClassLoader systemCL = ClassLoader.getSystemClassLoader();	94	private ClassLoader systemCL = TOP_CL;
94		95
95	/** A shared map of all packages known by all classloaders. Also covers META-INF based resources.	96	/** A shared map of all packages known by all classloaders. Also covers META-INF based resources.
96	* It contains two kinds of keys: dot-separated package names and slash-separated	97	* It contains two kinds of keys: dot-separated package names and slash-separated
Lines 112-117 public class ProxyClassLoader extends Cl Link Here
112	* automatically search through its parent list	113	* automatically search through its parent list
113	*/	114	*/
114	public ProxyClassLoader(ClassLoader[] parents, boolean transitive) {	115	public ProxyClassLoader(ClassLoader[] parents, boolean transitive) {
		116	super(TOP_CL);
115	this.transitive = transitive;	117	this.transitive = transitive;
116		118
117	this.parents = coalesceParents(parents);	119	this.parents = coalesceParents(parents);

Added Link Here

(-)264b7c1732cb (+190 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
5	*
6	* The contents of this file are subject to the terms of either the GNU
7	* General Public License Version 2 only ("GPL") or the Common
8	* Development and Distribution License("CDDL") (collectively, the
9	* "License"). You may not use this file except in compliance with the
10	* License. You can obtain a copy of the License at
11	* http://www.netbeans.org/cddl-gplv2.html
12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
13	* specific language governing permissions and limitations under the
14	* License. When distributing the software, include this License Header
15	* Notice in each file and include the License file at
16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
17	* particular file as subject to the "Classpath" exception as provided
18	* by Sun in the GPL Version 2 section of the License file that
19	* accompanied this code. If applicable, add the following below the
20	* License Header, with the fields enclosed by brackets [] replaced by
21	* your own identifying information:
22	* "Portions Copyrighted [year] [name of copyright owner]"
23	*
24	* If you wish your version of this file to be governed by only the CDDL
25	* or only the GPL Version 2, indicate your decision by adding
26	* "[Contributor] elects to include this software in this distribution
27	* under the [CDDL or GPL Version 2] license." If you do not indicate a
28	* single choice of license, a recipient has the option to distribute
29	* your version of this file under either the CDDL, the GPL Version 2 or
30	* to extend the choice of license to its licensees as provided above.
31	* However, if you add GPL Version 2 code and therefore, elected the GPL
32	* Version 2 license, then the option applies only if the new code is
33	* made subject to such option by the copyright holder.
34	*
35	* Contributor(s):
36	*
37	* Portions Copyrighted 2008 Sun Microsystems, Inc.
38	*/
39
40	package org.netbeans.junit;
41
42	import java.io.File;
43	import java.io.IOException;
44	import java.lang.reflect.Method;
45	import java.net.MalformedURLException;
46	import java.net.URISyntaxException;
47	import java.net.URL;
48	import java.net.URLClassLoader;
49	import java.util.ArrayList;
50	import java.util.Collection;
51	import java.util.Enumeration;
52	import java.util.LinkedHashSet;
53	import java.util.List;
54	import junit.framework.Assert;
55	import junit.framework.TestCase;
56	import junit.framework.TestResult;
57	import org.openide.util.Exceptions;
58	import org.openide.util.Lookup;
59
60	/**
61	*
62	* @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
63	*/
64	public class NbModuleSuite extends NbTestSuite {
65	private Class<?> clazz;
66
67	public NbModuleSuite(Class<?> aClass) {
68	super();
69	clazz = aClass;
70	}
71
72	@Override
73	public void run(TestResult result) {
74	try {
75	runInRuntimeContainer(result);
76	} catch (Exception ex) {
77	result.addError(this, ex);
78	}
79	}
80
81	private void runInRuntimeContainer(TestResult result) throws Exception {
82	File platform = findPlatform();
83	File[] boot = new File(platform, "lib").listFiles();
84	List<URL> bootCP = new ArrayList<URL>();
85	for (int i = 0; i < boot.length; i++) {
86	URL u = boot[i].toURL();
87	if (u.toExternalForm().endsWith(".jar")) {
88	bootCP.add(u);
89	}
90	}
91	// loader that does not see our current classloader
92	ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();
93	Assert.assertNotNull("Parent", parent);
94	URLClassLoader loader = new URLClassLoader(bootCP.toArray(new URL[0]), parent);
95	Class<?> main = loader.loadClass("org.netbeans.Main"); // NOI18N
96	Assert.assertEquals("Loaded by our classloader", loader, main.getClassLoader());
97	Method m = main.getDeclaredMethod("main", String[].class); // NOI18N
98
99	System.setProperty("java.util.logging.config", "-");
100	System.setProperty("netbeans.home", platform.getPath());
101
102	File ud = new File(new File(Manager.getWorkDirPath()), "userdir");
103	ud.mkdirs();
104	NbTestCase.deleteSubFiles(ud);
105
106	System.setProperty("netbeans.user", ud.getPath());
107
108	List<String> args = new ArrayList<String>();
109	args.add("--nosplash");
110	m.invoke(null, (Object)args.toArray(new String[0]));
111
112	ClassLoader global = Lookup.getDefault().lookup(ClassLoader.class);
113	Assert.assertNotNull("Global classloader is initialized", global);
114
115	URL[] testCP = preparePath(clazz);
116	JunitLoader testLoader = new JunitLoader(testCP, global, NbTestSuite.class.getClassLoader());
117	Class<?> sndClazz = testLoader.loadClass(clazz.getName());
118
119	new NbTestSuite(sndClazz).run(result);
120	}
121
122	private URL[] preparePath(Class<?>... classes) {
123	Collection<URL> cp = new LinkedHashSet<URL>();
124	for (Class c : classes) {
125	URL test = c.getProtectionDomain().getCodeSource().getLocation();
126	Assert.assertNotNull("URL found for " + c, test);
127	cp.add(test);
128	}
129	return cp.toArray(new URL[0]);
130	}
131
132
133	private File findPlatform() {
134	try {
135	File util = new File(Lookup.class.getProtectionDomain().getCodeSource().getLocation().toURI());
136	Assert.assertTrue("Util exists: " + util, util.exists());
137
138	return util.getParentFile().getParentFile();
139	} catch (URISyntaxException ex) {
140	Assert.fail("Cannot find utilities JAR");
141	return null;
142	}
143	}
144
145	private static final class JunitLoader extends URLClassLoader {
146	private final ClassLoader junit;
147
148	public JunitLoader(URL[] urls, ClassLoader parent, ClassLoader junit) {
149	super(urls, parent);
150	this.junit = junit;
151	}
152
153	@Override
154	protected Class<?> findClass(String name) throws ClassNotFoundException {
155	if (isUnit(name)) {
156	return junit.loadClass(name);
157	}
158	return super.findClass(name);
159	}
160
161	@Override
162	public URL findResource(String name) {
163	if (isUnit(name)) {
164	return junit.getResource(name);
165	}
166	return super.findResource(name);
167	}
168
169	@Override
170	public Enumeration<URL> findResources(String name) throws IOException {
171	if (isUnit(name)) {
172	return junit.getResources(name);
173	}
174	return super.findResources(name);
175	}
176
177	private final boolean isUnit(String res) {
178	if (res.startsWith("junit")) {
179	return true;
180	}
181	if (res.startsWith("org.junit") \|\| res.startsWith("org/junit")) {
182	return true;
183	}
184	if (res.startsWith("org.netbeans.junit") \|\| res.startsWith("org/netbeans/junit")) {
185	return true;
186	}
187	return false;
188	}
189	}
190	}

Added Link Here

(-)264b7c1732cb (+17 lines)
1	package org.netbeans.junit;
2
3	import junit.framework.TestCase;
4
5	public class NbModuleSuiteHelper extends TestCase {
6	static {
7	System.err.println("here");
8	}
9
10	public NbModuleSuiteHelper(String t) {
11	super(t);
12	}
13
14	public void testOne() {
15	System.setProperty("t.one", "OK");
16	}
17	}

Added Link Here

(-)264b7c1732cb (+74 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
5	*
6	* The contents of this file are subject to the terms of either the GNU
7	* General Public License Version 2 only ("GPL") or the Common
8	* Development and Distribution License("CDDL") (collectively, the
9	* "License"). You may not use this file except in compliance with the
10	* License. You can obtain a copy of the License at
11	* http://www.netbeans.org/cddl-gplv2.html
12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
13	* specific language governing permissions and limitations under the
14	* License. When distributing the software, include this License Header
15	* Notice in each file and include the License file at
16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
17	* particular file as subject to the "Classpath" exception as provided
18	* by Sun in the GPL Version 2 section of the License file that
19	* accompanied this code. If applicable, add the following below the
20	* License Header, with the fields enclosed by brackets [] replaced by
21	* your own identifying information:
22	* "Portions Copyrighted [year] [name of copyright owner]"
23	*
24	* If you wish your version of this file to be governed by only the CDDL
25	* or only the GPL Version 2, indicate your decision by adding
26	* "[Contributor] elects to include this software in this distribution
27	* under the [CDDL or GPL Version 2] license." If you do not indicate a
28	* single choice of license, a recipient has the option to distribute
29	* your version of this file under either the CDDL, the GPL Version 2 or
30	* to extend the choice of license to its licensees as provided above.
31	* However, if you add GPL Version 2 code and therefore, elected the GPL
32	* Version 2 license, then the option applies only if the new code is
33	* made subject to such option by the copyright holder.
34	*
35	* Contributor(s):
36	*
37	* Portions Copyrighted 2008 Sun Microsystems, Inc.
38	*/
39
40	package org.netbeans.junit;
41
42	import junit.framework.TestCase;
43	import junit.framework.TestResult;
44
45	/**
46	*
47	* @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
48	*/
49	public class NbModuleSuiteTest extends TestCase {
50
51	public NbModuleSuiteTest(String testName) {
52	super(testName);
53	}
54
55	@Override
56	protected void setUp() throws Exception {
57	super.setUp();
58	}
59
60	@Override
61	protected void tearDown() throws Exception {
62	super.tearDown();
63	}
64
65	/**
66	* Test of run method, of class NbModuleSuite.
67	*/
68	public void testRun() {
69	NbModuleSuite instance = new NbModuleSuite(NbModuleSuiteHelper.class);
70	junit.textui.TestRunner.run(instance);
71
72	assertEquals("OK", System.getProperty("t.one"));
73	}
74	}

Lines 55-65 made subject to such option by the copyr Link Here

(-)a/nbjunit/apichanges.xml (-1 / +22 lines)
55	<!-- ACTUAL CHANGES BEGIN HERE: -->	55	<!-- ACTUAL CHANGES BEGIN HERE: -->
56		56
57	<changes>	57	<changes>
		58	<change id="NbModuleSuite">
		59	<api name="nbjunit"/>
		60	<summary>Support class to allow excution of unit tests inside of NetBeans Runtime Container</summary>
		61	<version major="1" minor="46"/>
		62	<date day="29" month="2" year="2008"/>
		63	<author login="jtulach"/>
		64	<compatibility addition="yes"/>
		65	<description>
		66	<p>
		67	It always used to be hard to setup the right environment for test
		68	execution. In case this NetBeans this is even harder. The module
		69	system is ready to work without classpath isolation, however
		70	not every feature is available and every behaviour stays the
		71	same. That is why there is now the new <code>NbModuleSuite</code>
		72	support class that allows to really start the whole NetBeans
		73	Runtime Container, satisfy all the dependencies and only then
		74	load the testing class and execute it.
		75	</p>
		76	</description>
		77	<class package="org.netbeans.junit" name="NbModuleSuite"/>
		78	</change>
58	<change id="CollectData">	79	<change id="CollectData">
59	<api name="nbjunit"/>	80	<api name="nbjunit"/>
60	<summary>Support for Garbage Collecting of Log Message Arguments</summary>	81	<summary>Support for Garbage Collecting of Log Message Arguments</summary>
61	<version major="1" minor="44"/>	82	<version major="1" minor="44"/>
62	<date day="14" month="12" year="2006"/>	83	<date day="14" month="12" year="2007"/>
63	<author login="jtulach"/>	84	<author login="jtulach"/>
64	<compatibility addition="yes"/>	85	<compatibility addition="yes"/>
65	<description>	86	<description>