diff options
| author | Nick Drochak <nickd@mono-cvs.ximian.com> | 2002-01-19 22:55:23 +0300 |
|---|---|---|
| committer | Nick Drochak <nickd@mono-cvs.ximian.com> | 2002-01-19 22:55:23 +0300 |
| commit | b3a9502b960559d7a6b6c9712be8dd052b2e0e19 (patch) | |
| tree | da34a2b334adf9a39aacdd9432552db1bdd39999 /mcs/nunit/src/NUnitCore/TestCaseClassLoader.cs | |
| parent | aa634bb0419989a60379efba25e04e149936158e (diff) | |
* Added sources and makefile for NUnit
svn path=/trunk/mcs/; revision=2066
Diffstat (limited to 'mcs/nunit/src/NUnitCore/TestCaseClassLoader.cs')
| -rw-r--r-- | mcs/nunit/src/NUnitCore/TestCaseClassLoader.cs | 204 |
1 files changed, 204 insertions, 0 deletions
diff --git a/mcs/nunit/src/NUnitCore/TestCaseClassLoader.cs b/mcs/nunit/src/NUnitCore/TestCaseClassLoader.cs new file mode 100644 index 00000000000..52a73b6855e --- /dev/null +++ b/mcs/nunit/src/NUnitCore/TestCaseClassLoader.cs @@ -0,0 +1,204 @@ +namespace NUnit.Runner {
+ using System;
+/// <summary>
+///
+/// </summary>
+ public class TestCaseClassLoader : StandardTestSuiteLoader {
+ /// <summary>
+ ///
+ /// </summary>
+ /// <param name="name"></param>
+ /// <param name="resolve"></param>
+ /// <returns></returns>
+ public Type LoadClass(string name, bool resolve) {
+ return Load(name);
+ }
+/// <summary>
+///
+/// </summary>
+/// <param name="name"></param>
+/// <returns></returns>
+ public bool IsExcluded(string name) {
+ return false;
+ }
+ }
+}
+
+
+#if false
+
+// commented out till figure out .net class reloading
+
+namespace NUnit.Runner {
+
+ /**
+ * A custom class loader which enables the reloading
+ * of classes for each test run. The class loader
+ * can be configured with a list of package paths that
+ * should be excluded from loading. The loading
+ * of these packages is delegated to the system class
+ * loader. They will be shared across test runs.
+ * <p>
+ * The list of excluded package paths is specified in
+ * a properties file "excluded.properties" that is located in
+ * the same place as the TestCaseClassLoader class.
+ * <p>
+ * <b>Known limitation:</b> the TestCaseClassLoader cannot load classes
+ * from jar files.
+ */
+
+
+ public class TestCaseClassLoader: ClassLoader {
+ /** scanned class path */
+ private string[] fPathItems;
+ /** excluded paths */
+ private string[] fExcluded= { "com.sun.", "sun."};
+ /** name of excluded properties file */
+ static final string EXCLUDED_FILE= "excluded.properties";
+ /**
+ * Constructs a TestCaseLoader. It scans the class path
+ * and the excluded package paths
+ */
+ public TestCaseClassLoader() {
+ super();
+ string classPath= System.getProperty("java.class.path");
+ string separator= System.getProperty("path.separator");
+
+ // first pass: count elements
+ StringTokenizer st= new StringTokenizer(classPath, separator);
+ int i= 0;
+ while (st.hasMoreTokens()) {
+ st.nextToken();
+ i++;
+ }
+ // second pass: split
+ fPathItems= new string[i];
+ st= new StringTokenizer(classPath, separator);
+ i= 0;
+ while (st.hasMoreTokens()) {
+ fPathItems[i++]= st.nextToken();
+ }
+
+ string[] excluded= ReadExcludedPackages();
+ if (excluded != null)
+ fExcluded= excluded;
+ }
+ public java.net.URL GetResource(string name) {
+ return ClassLoader.getSystemResource(name);
+ }
+ public InputStream GetResourceAsStream(string name) {
+ return ClassLoader.getSystemResourceAsStream(name);
+ }
+ protected boolean IsExcluded(string name) {
+ // exclude the "java" and "junit" packages.
+ // They always need to be excluded so that they are loaded by the system class loader
+ if (name.startsWith("java.") ||
+ name.startsWith("junit.framework") ||
+ name.startsWith("junit.extensions") ||
+ name.startsWith("junit.util") ||
+ name.startsWith("junit.ui"))
+ return true;
+
+ // exclude the user defined package paths
+ for (int i= 0; i < fExcluded.length; i++) {
+ if (name.startsWith(fExcluded[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+ public synchronized Class LoadClass(string name, boolean resolve)
+ throws ClassNotFoundException {
+
+ Class c= FindLoadedClass(name);
+ if (c != null)
+ return c;
+ //
+ // Delegate the loading of excluded classes to the
+ // standard class loader.
+ //
+ if (IsExcluded(name)) {
+ try {
+ c= findSystemClass(name);
+ return c;
+ } catch (ClassNotFoundException e) {
+ // keep searching
+ }
+ }
+ if (c == null) {
+ File file= Locate(name);
+ if (file == null)
+ throw new ClassNotFoundException();
+ byte data[]= LoadClassData(file);
+ c= defineClass(name, data, 0, data.length);
+ }
+ if (resolve)
+ resolveClass(c);
+ return c;
+ }
+ private byte[] LoadClassData(File f) throws ClassNotFoundException {
+ try {
+ //System.out.println("loading: "+f.getPath());
+ FileInputStream stream= new FileInputStream(f);
+
+ try {
+ byte[] b= new byte[stream.available()];
+ stream.read(b);
+ stream.close();
+ return b;
+ }
+ catch (IOException e) {
+ throw new ClassNotFoundException();
+ }
+ }
+ catch (FileNotFoundException e) {
+ throw new ClassNotFoundException();
+ }
+ }
+ /**
+ * Locate the given file.
+ * @return Returns null if file couldn't be found.
+ */
+ private File Locate(string fileName) {
+ fileName= fileName.replace('.', '/')+".class";
+ File path= null;
+
+ if (fileName != null) {
+ for (int i= 0; i < fPathItems.length; i++) {
+ path= new File(fPathItems[i], fileName);
+ if (path.exists())
+ return path;
+ }
+ }
+ return null;
+ }
+ private string[] ReadExcludedPackages() {
+ InputStream is= getClass().GetResourceAsStream(EXCLUDED_FILE);
+ if (is == null)
+ return null;
+ Properties p= new Properties();
+ try {
+ p.Load(is);
+ }
+ catch (IOException e) {
+ return null;
+ }
+ Vector v= new Vector(10);
+ for (Enumeration e= p.propertyNames(); e.hasMoreElements(); ) {
+ string key= (string)e.nextElement();
+ if (key.startsWith("excluded.")) {
+ string path= p.getProperty(key);
+ if (path.endsWith("*"))
+ path= path.substring(0, path.length()-1);
+ if (path.length() > 0)
+ v.addElement(path);
+ }
+ }
+ string[] excluded= new string[v.size()];
+ for (int i= 0; i < v.size(); i++)
+ excluded[i]= (string)v.elementAt(i);
+ return excluded;
+ }
+ }
+
+#endif
|