/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.junit;

import java.awt.HeadlessException;
import java.awt.Rectangle;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import junit.framework.Assert;
import junit.framework.AssertionFailedError;
import junit.framework.Protectable;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestFailure;
import junit.framework.TestResult;
import org.netbeans.junit.internal.NbModuleLogHandler;

/**
 * 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>
 * For more advanced configuration see {@link #emptyConfiguration()} and {@link Configuration}.
 *
 * @since 1.46
 * @author Jaroslav Tulach <jaroslav.tulach@netbeans.org>
 */
public class NbModuleSuite {
    private static final Logger LOG;

    static {
        System.setProperty("org.netbeans.MainImpl.154417", "true");
        LOG = Logger.getLogger(NbModuleSuite.class.getName());
    }

    private NbModuleSuite() {}
    
    
    /** Settings object that allows one to configure execution of
     * whole {@link NbModuleSuite}. Chain the method invocations
     * (each method returns new instance of {@link Configuration})
     * and call {@link #suite()} at the end to generate the final
     * JUnit test class.
     * 
     * @since 1.48
     */
    public static final class Configuration extends Object {
        final List<Item> tests;
        final Class<? extends TestCase> latestTestCaseClass;
        final List<String> clusterRegExp;
        /** each odd is cluster reg exp, each even is module reg exp */
        final List<String> moduleRegExp;
        final List<String> startupArgs;
        final ClassLoader parentClassLoader;
        final boolean reuseUserDir;
        final boolean gui;
        final boolean enableClasspathModules;
        final boolean honorAutoEager;
        final boolean hideExtraModules;
        final Level failOnMessage;
        final Level failOnException;

        private Configuration(
            List<String> clusterRegExp,
            List<String> moduleRegExp,
            List<String> startupArgs,
            ClassLoader parent,
            List<Item> testItems,
            Class<? extends TestCase> latestTestCase,
            boolean reuseUserDir,
            boolean gui,
            boolean enableCPModules,
            boolean honorAutoEager,
            Level failOnMessage,
            Level failOnException,
            boolean hideExtraModules    
        ) {
            this.clusterRegExp = clusterRegExp;
            this.moduleRegExp = moduleRegExp;
            this.startupArgs = startupArgs;
            this.parentClassLoader = parent;
            this.tests = testItems;
            this.reuseUserDir = reuseUserDir;
            this.latestTestCaseClass = latestTestCase;
            this.gui = gui;
            this.enableClasspathModules = enableCPModules;
            this.honorAutoEager = honorAutoEager;
            this.failOnException = failOnException;
            this.failOnMessage = failOnMessage;
            this.hideExtraModules = hideExtraModules;
        }

        static Configuration create(Class<? extends TestCase> clazz) {            
            return new Configuration(
                null, null, null, ClassLoader.getSystemClassLoader().getParent(),
                Collections.<Item>emptyList(), clazz, false, true, true, false
                , null, null, false);
        }
        
        /** Regular expression to match clusters that shall be enabled.
         * To enable all cluster, one can use <code>".*"</code>. To enable
         * ide and java clusters, it is handy to pass in <code>"ide|java"</code>.
         * There is no need to request presence of <code>platform</code> cluster,
         * as that is available all the time by default.
         * <p>
         * Since version 1.55 this method can be called multiple times.
         * 
         * @param regExp regular expression to match cluster names
         * @return clone of this configuration with cluster set to regExp value
         */
        public Configuration clusters(String regExp) {
            ArrayList<String> list = new ArrayList<String>();
            if (clusterRegExp != null) {
                list.addAll(clusterRegExp);
            }
            if (regExp != null) {
                list.add(regExp);
            }
            if (list.isEmpty()) {
                list = null;
            }
            return new Configuration(
                list, moduleRegExp, startupArgs, parentClassLoader, tests,
                latestTestCaseClass, reuseUserDir, gui, enableClasspathModules,
                honorAutoEager
            , failOnMessage, failOnException, hideExtraModules);
        }

        /** By default only modules on classpath of the test are enabled, 
         * the rest are just autoloads. If you need to enable more, you can
         * specify that with this method. To enable all available modules
         * in all clusters pass in <code>".*"</code>. Since 1.55 this method
         * is cummulative.
         * 
         * @param regExp regular expression to match code name base of modules
         * @return clone of this configuration with enable modules set to regExp value
         */
        public Configuration enableModules(String regExp) {
            if (regExp == null) {
                return this;
            }
            return enableModules(".*", regExp);
        }

        /** By default only modules on classpath of the test are enabled,
         * the rest are just autoloads. If you need to enable more, you can
         * specify that with this method. To enable all available modules in
         * one cluster, use this method and pass <code>".*"</code> as list of
         * modules. This method is cumulative.
         *
         * @param clusterRegExp regular expression to match clusters
         * @param moduleRegExp regular expression to match code name base of modules
         * @return clone of this configuration with enable modules set to regExp value
         * @since 1.55
         */
        public Configuration enableModules(String clusterRegExp, String moduleRegExp) {
            List<String> arr = new ArrayList<String>();
            if (this.moduleRegExp != null) {
                arr.addAll(this.moduleRegExp);
            }
            arr.add(clusterRegExp);
            arr.add(moduleRegExp);
            return new Configuration(
                this.clusterRegExp, arr, startupArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir, gui,
                enableClasspathModules, honorAutoEager, failOnMessage, 
                failOnException, hideExtraModules);
        }
        
        /**
         * Appends one or more command line arguments which will be used to 
         * start the application.  Arguments which take a parameter should
         * usually be specified as two separate strings.  Also note that this
         * method cannot handle arguments which must be passed directly to the 
         * JVM (such as memory settings or system properties), those should be 
         * instead specified in the <code>test.run.args</code> property (e.g.
         * in the module's <code>project.properties</code> file).
         * 
         * @param arguments command line arguments to append; each value
         * specified here will be passed a separate argument when starting
         * the application under test.
         * @return clone of this configuration object with the specified
         * command line arguments appended to any which may have already 
         * been present
         * @since 1.67
         */
        public Configuration addStartupArgument(String... arguments) {
            if (arguments == null || arguments.length < 1){
                throw new IllegalStateException("Must specify at least one startup argument");
            }

            List<String> newArgs = new ArrayList<String>();
            if (startupArgs != null) {
                newArgs.addAll(startupArgs);
            }
            newArgs.addAll(Arrays.asList(arguments));

            return new Configuration(
                clusterRegExp, moduleRegExp, newArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir, gui,
                enableClasspathModules, honorAutoEager, failOnMessage, 
                failOnException, hideExtraModules);
        }

        Configuration classLoader(ClassLoader parent) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parent, tests,
                latestTestCaseClass, reuseUserDir, gui, enableClasspathModules,
                honorAutoEager
            , failOnMessage, failOnException, hideExtraModules);
        }

        /** Adds new test name, or array of names into the configuration. By 
         * default the suite executes all <code>testXYZ</code> 
         * methods present in the test class
         * (the one passed into {@link Configuration#create(java.lang.Class)}
         * method). However if there is a need to execute just some of them,
         * one can use this method to explicitly enumerate them by subsequent
         * calls to <code>addTest</code> method.
         * @param testNames list names to add to the test execution
         * @return clone of this configuration with testNames test added to the 
         *    list of executed tests
         */
        public Configuration addTest(String... testNames) {
            if (latestTestCaseClass == null){
                throw new IllegalStateException();
            }
            List<Item> newTests = new ArrayList<Item>(tests);
            newTests.add(new Item(true, latestTestCaseClass, testNames));
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                newTests, latestTestCaseClass, reuseUserDir, gui,
                enableClasspathModules, honorAutoEager, failOnMessage, 
                failOnException, hideExtraModules);
        }
        
        /** Adds new test class to run, together with a list of its methods
         * that shall be executed. The list can be empty and if so, the 
         * the suite executes all <code>testXYZ</code> 
         * methods present in the test class.
         * 
         * @param test the class to also execute in this suite
         * @param testNames list names to add to the test execution
         * @return clone of this configuration with testNames test added to the 
         *    list of executed tests
         * @since 1.50
         */
        public Configuration addTest(Class<? extends TestCase> test, String... testNames) {
            if (test.equals(latestTestCaseClass)){
                return addTest(testNames);
            }
            List<Item> newTests = new ArrayList<Item>(tests);
            addLatest(newTests);
            if ((testNames != null) && (testNames.length != 0)){
                newTests.add(new Item(true, test, testNames));
            }
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                newTests, test, reuseUserDir, gui, enableClasspathModules,
                honorAutoEager
            , failOnMessage, failOnException, hideExtraModules);
        }
        
        /**
         * Add new {@link  junit.framework.Test} to run. The implementation must
         * have no parameter constructor. TastCase can be also passed as an argument
         * of this method than it's delegated to
         * {@link Configuration#addTest(java.lang.Class, java.lang.String[]) }
         *  
         * @param test Test implementation to add
         * @return clone of this configuration with new Test added to the list
         *  of executed tests
         * @since 1.50
         */
        public Configuration addTest(Class<? extends Test> test) {
            if (TestCase.class.isAssignableFrom(test)){
                Class<? extends TestCase> tc = test.asSubclass(TestCase.class);
                return addTest(tc, new String[0]);
            }
            List<Item> newTests = new ArrayList<Item>(tests);
            newTests.add(new Item(false, test, null));
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                newTests, latestTestCaseClass, reuseUserDir,
                gui, enableClasspathModules, honorAutoEager
            , failOnMessage, failOnException, hideExtraModules);
        }

        /** By default all modules on classpath are enabled (so you can link
         * with modules that you compile against), this method allows you to
         * disable this feature, which is useful if the test is known to not
         * link against any of classpath classes.
         *
         * @param enable pass false to ignore modules on classpath
         * @return new configuration clone
         * @since 1.56
         */
        public Configuration enableClasspathModules(boolean enable) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir,
                gui, enable, honorAutoEager, failOnMessage, failOnException, hideExtraModules);
        }

        /** By default the {@link #enableModules(java.lang.String)} method
         * converts all autoloads into regular modules and enables them. This
         * is maybe useful in certain situations, but does not really mimic the
         * real behaviour of the system when it is executed. Those who need
         * to as closely as possible simulate the real run, can use
         * <code>honorAutoloadEager(true)</code>.
         *
         * @param honor true in case autoloads shall remain autoloads and eager modules eager
         * @return new configuration filled with this data
         * @since 1.57
         */
        public Configuration honorAutoloadEager(boolean honor) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir,
                gui, enableClasspathModules, honor
            , failOnMessage, failOnException, hideExtraModules);
        }
        
        /** Allows to limit what modules get enabled in the system.
         * The original purpose of {@link NbModuleSuite} was to enable
         * as much of modules as possible. This was believed to 
         * resemble the real situation in the running application the best.
         * However it turned out there
         * are situations when too much modules can break the system
         * and it is necessary to prevent loading some of them.
         * This method can achieve that.
         * <p>
         * The primary usage is for <em>Ant</em> based harness. It usually
         * contains full installation of various clusters and the application
         * picks just certain modules from that configuration. 
         * <code>hideExtraModules(true)</code> allows exclusion of these
         * modules as well.
         * <p>
         * The usefulness of this method in <em>Maven</em> based environment
         * is not that big. Usually the nbm plugin makes only necessary
         * JARs available. In combination with {@link #enableClasspathModules(boolean) 
         * enableClasspathModules(false)}, it may give you a subset of
         * the Platform loaded in a test. In a
         * Maven-based app declaring a dependency on the whole 
         * org.netbeans.cluster:platform use the following suite expression:
         * <pre>
         * NbModuleSuite.createConfiguration(ApplicationTest.class).
         *     gui(true).
         *     hideExtraModules(true).
         *     enableModules("(?!org.netbeans.modules.autoupdate|org.netbeans.modules.core.kit|org.netbeans.modules.favorites).*").
         *     enableClasspathModules(false).
         *     suite();
         * </pre>
         * 
         * @param hide true if all enabled not explicitly requested modules should
         *   be hidden
         * @return new configuration with holds the provided parameter
         * @since 1.72
         */
        public Configuration hideExtraModules(boolean hide) {
            return new Configuration(
                    clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                    tests, latestTestCaseClass, reuseUserDir,
                    gui, enableClasspathModules, honorAutoEager, failOnMessage, 
                    failOnException, hide);
        }

        /** Fails if there is a message sent to {@link Logger} with appropriate
         * level or higher during the test run execution.
         *
         * @param level the minimal level of the message
         * @return new configuration filled with this data
         * @since 1.58
         */
        public Configuration failOnMessage(Level level) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir,
                gui, enableClasspathModules, honorAutoEager
                , level, failOnException, hideExtraModules);
        }

        /** Fails if there is an exception reported to {@link Logger} with appropriate
         * level or higher during the test run execution.
         *
         * @param level the minimal level of the message
         * @return new configuration filled with this data
         * @since 1.58
         */
        public Configuration failOnException(Level level) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir,
                gui, enableClasspathModules, honorAutoEager
                , failOnMessage, level, hideExtraModules);
        }

        private void addLatest(List<Item> newTests) {
            if (latestTestCaseClass == null){
                return;
            }
            for (Item item : newTests) {
                if (item.clazz.equals(latestTestCaseClass)){
                    return;
                }
            }
            newTests.add(new Item(true, latestTestCaseClass, null));
        }

        private Configuration getReady() {
            List<Item> newTests = new ArrayList<Item>(tests);
            addLatest(newTests);

            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                newTests, latestTestCaseClass, reuseUserDir, gui,
                enableClasspathModules
            ,honorAutoEager, failOnMessage, failOnException, hideExtraModules);
        }
        
        /** Should the system run with GUI or without? The default behaviour
         * does not prevent any module to show UI. If <code>false</code> is 
         * used, then the whole system is instructed with <code>--nogui</code>
         * option that it shall run as much as possible in invisible mode. As
         * a result, the main window is not shown after the start, for example.
         * 
         * @param gui true or false
         * @return clone of this configuration with gui mode associated
         */
        public Configuration gui(boolean gui) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader,
                tests, latestTestCaseClass, reuseUserDir, gui,
                enableClasspathModules
            ,honorAutoEager, failOnMessage, failOnException, hideExtraModules);
        }

        /**
         * Enables or disables userdir reuse. By default it is disabled.
         * @param reuse true or false
         * @return clone of this configuration with userdir reuse mode associated
         * @since 1.52
         */
        public Configuration reuseUserDir(boolean reuse) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentClassLoader, tests,
                latestTestCaseClass, reuse, gui, enableClasspathModules
            ,honorAutoEager, failOnMessage, failOnException, hideExtraModules);
        }

        /**
         * Sets the parent ClassLoader on which the NB platform should start.
         * @param parentCL the parent ClassLoader
         * @return clone of this configuration with the parent ClassLoader set
         * @since 1.91
         */
        public Configuration parentClassLoader(ClassLoader parentCL) {
            return new Configuration(
                clusterRegExp, moduleRegExp, startupArgs, parentCL, tests,
                latestTestCaseClass, reuseUserDir, gui, enableClasspathModules
            ,honorAutoEager, failOnMessage, failOnException, hideExtraModules);
        }

        /**
         * Creates a test suite from this configuration.
         * Same as {@link #create(org.netbeans.junit.NbModuleSuite.Configuration)} but more fluid.
         * @return a suite ready for returning from a {@code public static Test suite()} method
         * @since org.netbeans.modules.junit/1 1.70
         */
        public Test suite() {
            return new S(this);
        }

    }

    /** Factory method to create wrapper test that knows how to setup proper
     * NetBeans Runtime Container environment. 
     * 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.
     * In addition,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
     * @param moduleRegExp by default all modules on classpath are turned on,
     *    however this regular expression can specify additional ones. If not
     *    null, the specified cluster will be searched for modules with such
     *    codenamebase and those will be turned on
     * @return runtime container ready test
     */
    public static Test create(Class<? extends TestCase> clazz, String clustersRegExp, String moduleRegExp) {
        return Configuration.create(clazz).clusters(clustersRegExp).enableModules(moduleRegExp).suite();
    }
    
    /** Factory method to create wrapper test that knows how to setup proper
     * NetBeans Runtime Container environment. 
     * 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.
     * In addition,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
     * @param moduleRegExp by default all modules on classpath are turned on,
     *    however this regular expression can specify additional ones. If not
     *    null, the specified cluster will be searched for modules with such
     *    codenamebase and those will be turned on
     * @param tests names of test methods to execute from the <code>clazz</code>, if
     *    no test methods are specified, all tests in the class are executed
     * @return runtime container ready test
     * @since 1.49
     */
    public static Test create(Class<? extends TestCase> clazz, String clustersRegExp, String moduleRegExp, String... tests) {
        Configuration conf = Configuration.create(clazz).clusters(clustersRegExp).enableModules(moduleRegExp);
        if (tests.length > 0) {
            conf = conf.addTest(tests);
        } 
        return conf.suite();
    }
    
    /** Factory method to create wrapper test that knows how to setup proper
     * NetBeans Runtime Container environment. 
     * Wraps the provided class into a test that set ups properly the
     * testing environment. All modules, in all clusters, 
     * in the tested applicationwill be included in the test. 
     * 
     * @param clazz the class with bunch of testXYZ methods
     * @param tests names of test methods to execute from the <code>clazz</code>, if
     *    no test methods are specified, all tests in the class are executed
     * @return runtime container ready test
     * @since 1.49
     */
    public static Test allModules(Class<? extends TestCase> clazz, String... tests) {
        return create(clazz, ".*", ".*", tests);
    }
    
    /** Creates default configuration wrapping a class that can be executed
     * with the {@link NbModuleSuite} support.
     * 
     * @param clazz the class to test, the actual instances will be created
     *   for the class of the same name, but loaded by different classloader
     * @return config object prefilled with default values; the defaults may
     *   be altered with its addition instance methods
     * @since 1.48
     */
    public static Configuration createConfiguration(Class<? extends TestCase> clazz) {
        return Configuration.create(clazz);
    }
    
    /** Creates empty configuration without any class assiciated. You need
     * to call {@link Configuration#addTest(java.lang.Class, java.lang.String[])}
     * then to register proper test classes.
     * 
     * @return config object prefilled with default values; the defaults may
     *   be altered with its addition instance methods
     * @since 1.50
     */
    public static Configuration emptyConfiguration() {
        return Configuration.create(null);
    }
    
    
    /** Factory method to create wrapper test that knows how to setup proper
     * NetBeans Runtime Container environment. This method allows better
     * customization and control over the executed set of tests.
     * Wraps the provided class into a test that set ups properly the
     * testing environment, read more in {@link Configuration}.
     * 
     * 
     * @param config the configuration for the test
     * @return runtime container ready test
     * @since 1.48
     * @see Configuration#suite
     */
    public static Test create(Configuration config) {
        return config.suite();
    }

    private static final class Item {
        boolean isTestCase;
        Class<?> clazz;
        String[] fileNames;

        public Item(boolean isTestCase, Class<?> clazz, String[] fileNames) {
            this.isTestCase = isTestCase;
            this.clazz = clazz;
            this.fileNames = fileNames;
        }
    }

    static final class S extends NbTestSuite {
        final Configuration config;
        private static int invocations;
        private static File lastUserDir;
        private int testCount = 0; 
        
        public S(Configuration config) {
            this.config = config.getReady();
        }

        @Override
        public int countTestCases() {
            return testCount;
        }

        @Override
        public void run(final TestResult result) {
            result.runProtected(this, new Protectable() {
                public @Override void protect() throws Throwable {
                    ClassLoader before = Thread.currentThread().getContextClassLoader();
                    try {
                        runInRuntimeContainer(result);
                    } finally {
                        Thread.currentThread().setContextClassLoader(before);
                    }
                }
            });
        }
        
        private static String[] tokenizePath(String path) {
            List<String> l = new ArrayList<String>();
            StringTokenizer tok = new StringTokenizer(path, ":;", true); // NOI18N
            char dosHack = '\0';
            char lastDelim = '\0';
            int delimCount = 0;
            while (tok.hasMoreTokens()) {
                String s = tok.nextToken();
                if (s.length() == 0) {
                    // Strip empty components.
                    continue;
                }
                if (s.length() == 1) {
                    char c = s.charAt(0);
                    if (c == ':' || c == ';') {
                        // Just a delimiter.
                        lastDelim = c;
                        delimCount++;
                        continue;
                    }
                }
                if (dosHack != '\0') {
                    // #50679 - "C:/something" is also accepted as DOS path
                    if (lastDelim == ':' && delimCount == 1 && (s.charAt(0) == '\\' || s.charAt(0) == '/')) {
                        // We had a single letter followed by ':' now followed by \something or /something
                        s = "" + dosHack + ':' + s;
                        // and use the new token with the drive prefix...
                    } else {
                        // Something else, leave alone.
                        l.add(Character.toString(dosHack));
                        // and continue with this token too...
                    }
                    dosHack = '\0';
                }
                // Reset count of # of delimiters in a row.
                delimCount = 0;
                if (s.length() == 1) {
                    char c = s.charAt(0);
                    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
                        // Probably a DOS drive letter. Leave it with the next component.
                        dosHack = c;
                        continue;
                    }
                }
                l.add(s);
            }
            if (dosHack != '\0') {
                //the dosHack was the last letter in the input string (not followed by the ':')
                //so obviously not a drive letter.
                //Fix for issue #57304
                l.add(Character.toString(dosHack));
            }
            return l.toArray(new String[l.size()]);
        }

        static void findClusters(Collection<File> clusters, List<String> regExps) throws IOException {
            File plat = findPlatform().getCanonicalFile();
            String selectiveClusters = System.getProperty("cluster.path.final"); // NOI18N
            Set<File> path;
            if (selectiveClusters != null) {
                path = new TreeSet<File>();
                for (String p : tokenizePath(selectiveClusters)) {
                    File f = new File(p);
                    path.add(f.getCanonicalFile());
                }
            } else {
                File parent;
                String allClusters = System.getProperty("all.clusters"); // #194794
                if (allClusters != null) {
                    parent = new File(allClusters);
                } else {
                    parent = plat.getParentFile();
                }
                path = new TreeSet<File>(Arrays.asList(parent.listFiles()));
            }
            for (String c : regExps) {
                for (File f : path) {
                    if (f.equals(plat)) {
                        continue;
                    }
                    if (!f.getName().matches(c)) {
                        continue;
                    }
                    File m = new File(new File(f, "config"), "Modules");
                    if (m.exists()) {
                        clusters.add(f);
                    }
                }
            }
        }

        private void runInRuntimeContainer(TestResult result) throws Exception {
            System.getProperties().remove("netbeans.dirs");
            File platform = findPlatform();
            List<URL> bootCP = new ArrayList<URL>();
            List<File> dirs = new ArrayList<File>();
            dirs.add(new File(platform, "lib"));
            
            File jdkHome = new File(System.getProperty("java.home"));
            if (new File(jdkHome.getParentFile(), "lib").exists()) {
                jdkHome = jdkHome.getParentFile();
            }
            dirs.add(new File(jdkHome, "lib"));

            //in case we're running code coverage, load the coverage libraries
            if (System.getProperty("code.coverage.classpath") != null) {
                dirs.add(new File(System.getProperty("code.coverage.classpath")));
            }

            for (File dir: dirs) {
                File[] jars = dir.listFiles();
                if (jars != null) {
                    for (File jar : jars) {
                        if (jar.getName().endsWith(".jar")) {
                            bootCP.add(toURI(jar).toURL());
                        }
                    }
                }
            }
            
            // loader that does not see our current classloader
            JUnitLoader junit = new JUnitLoader(config.parentClassLoader, NbModuleSuite.class.getClassLoader());
            URLClassLoader loader = new URLClassLoader(bootCP.toArray(new URL[0]), junit);
            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.logger.console", "true");
            if (System.getProperty("netbeans.logger.noSystem") == null) {
                System.setProperty("netbeans.logger.noSystem", "true");
            }
            System.setProperty("netbeans.home", platform.getPath());
            System.setProperty("netbeans.full.hack", "true");

            String branding = System.getProperty("branding.token"); // NOI18N
            if (branding != null) {
                try {
                    Method setBranding = loader.loadClass("org.openide.util.NbBundle").getMethod("setBranding", String.class); // NOI18N
                    setBranding.invoke(null, branding);
                } catch (Throwable ex) {
                    if (ex instanceof InvocationTargetException) {
                        ex = ((InvocationTargetException)ex).getTargetException();
                    }
                    LOG.log(Level.WARNING, "Cannot set branding to " + branding, ex); // NOI18N
                }
            }
            
            File ud = new File(new File(Manager.getWorkDirPath()), "userdir" + invocations++);
            if (config.reuseUserDir) {
                ud = lastUserDir != null ? lastUserDir : ud;
            } else {
                NbTestCase.deleteSubFiles(ud);
            }
            lastUserDir = ud;
            ud.mkdirs();

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

            TreeSet<String> modules = new TreeSet<String>();
            if (config.enableClasspathModules) {
                modules.addAll(findEnabledModules(NbTestSuite.class.getClassLoader()));
            }
            modules.add("org.openide.filesystems");
            modules.add("org.openide.modules");
            modules.add("org.openide.util");
            modules.add("org.openide.util.ui");
            modules.remove("org.netbeans.insane");
            modules.add("org.netbeans.core.startup");
            modules.add("org.netbeans.core.startup.base");
            modules.add("org.netbeans.bootstrap");
            turnModules(ud, !config.honorAutoEager, modules, config.moduleRegExp, platform);
            if (config.enableClasspathModules) {
                turnClassPathModules(ud, NbTestSuite.class.getClassLoader());
            }

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

            if (config.hideExtraModules) {
                Collection<File> clusters = new LinkedHashSet<File>();
                if (config.clusterRegExp != null) {
                    findClusters(clusters, config.clusterRegExp);
                }
                clusters.add(findPlatform());
                for (File f : clusters) {
                    disableModules(ud, f);
                }
            }

            System.setProperty("netbeans.security.nocheck", "true");

            List<Class<?>> allClasses = new ArrayList<Class<?>>(config.tests.size());
            for (Item item : config.tests) {
                allClasses.add(item.clazz);
            }
            preparePatches(System.getProperty("java.class.path"), System.getProperties(), allClasses.toArray(new Class<?>[0]));
            
            List<String> args = new ArrayList<String>();
            args.add("--nosplash");
            if (!config.gui) {
                args.add("--nogui");
            }

            if (config.startupArgs != null) {
                args.addAll(config.startupArgs);
            }

            Test handler = NbModuleLogHandler.registerBuffer(config.failOnMessage, config.failOnException);
            m.invoke(null, (Object)args.toArray(new String[0]));

            ClassLoader global = Thread.currentThread().getContextClassLoader();
            Assert.assertNotNull("Global classloader is initialized", global);
            ClassLoader testLoader = global;
            try {
                testLoader.loadClass("junit.framework.Test");
                testLoader.loadClass("org.netbeans.junit.NbTestSuite");
                NbTestSuite toRun = new NbTestSuite();
                
                for (Item item : config.tests) {
                    if (item.isTestCase){
                        Class<? extends TestCase> sndClazz =
                            testLoader.loadClass(item.clazz.getName()).asSubclass(TestCase.class);
                        if (item.fileNames == null) {
                            MethodOrder.orderMethods(sndClazz, null);
                            toRun.addTest(new NbTestSuiteLogCheck(sndClazz));
                        } else {
                            NbTestSuite t = new NbTestSuiteLogCheck();
                            t.addTests(sndClazz, item.fileNames);
                            toRun.addTest(t);
                        }
                    }else{
                        Class<? extends Test> sndClazz =
                            testLoader.loadClass(item.clazz.getName()).asSubclass(Test.class);
                        toRun.addTest(sndClazz.newInstance());
                    }
                }

                if (handler != null) {
                    toRun.addTest(handler);
                }

                testCount = toRun.countTestCases();
                toRun.run(result);
            } catch (ClassNotFoundException ex) {
                result.addError(this, ex);
            } catch (NoClassDefFoundError ex) {
                result.addError(this, ex);
            }
            if (handler != null) {
                NbModuleLogHandler.finish();
            }
            String n;
            if (config.latestTestCaseClass != null) {
                n = config.latestTestCaseClass.getName();
            } else {
                n = "exit"; // NOI18N
            }
            TestResult shutdownResult = new Shutdown(global, n).run();
            if (shutdownResult.failureCount() > 0) {
                final TestFailure tf = shutdownResult.failures().nextElement();
                result.addFailure(tf.failedTest(), (AssertionFailedError)tf.thrownException());
            }
            if (shutdownResult.errorCount() > 0) {
                final TestFailure tf = shutdownResult.errors().nextElement();
                result.addError(tf.failedTest(), tf.thrownException());
            }
        }

        static File findPlatform() {
            String clusterPath = System.getProperty("cluster.path.final"); // NOI18N
            if (clusterPath != null) {
                for (String piece : tokenizePath(clusterPath)) {
                    File d = new File(piece);
                    if (d.getName().matches("platform\\d*")) {
                        return d;
                    }
                }
            }
            String allClusters = System.getProperty("all.clusters"); // #194794
            if (allClusters != null) {
                File d = new File(allClusters, "platform"); // do not bother with old numbered variants
                if (d.isDirectory()) {
                    return d;
                }
            }
            try {
                Class<?> lookup = Class.forName("org.openide.util.Lookup"); // NOI18N
                File util = toFile(lookup.getProtectionDomain().getCodeSource().getLocation().toURI());
                Assert.assertTrue("Util exists: " + util, util.exists());

                return util.getParentFile().getParentFile();
            } catch (Exception ex) {
                try {
                    File nbjunit = toFile(NbModuleSuite.class.getProtectionDomain().getCodeSource().getLocation().toURI());
                    File harness = nbjunit.getParentFile().getParentFile();
                    Assert.assertEquals(nbjunit + " is in a folder named 'harness'", "harness", harness.getName());
                    TreeSet<File> sorted = new TreeSet<File>();
                    for (File p : harness.getParentFile().listFiles()) {
                        if (p.getName().startsWith("platform")) {
                            sorted.add(p);
                        }
                    }
                    Assert.assertFalse("Platform shall be found in " + harness.getParent(), sorted.isEmpty());
                    return sorted.last();
                } catch (Exception ex2) {
                    Assert.fail("Cannot find utilities JAR: " + ex + " and: " + ex2);
                }
                return null;
            }
        }

        private File[] findClusters() throws IOException {
            Collection<File> clusters = new LinkedHashSet<File>();
            if (config.clusterRegExp != null) {
                findClusters(clusters, config.clusterRegExp);
            }

            if (config.enableClasspathModules) {
                // find "cluster" from
                // k/o.n.m.a.p.N/csam/testModule/build/cluster/modules/org-example-testModule.jar
                // tested in apisupport.project
                for (String s : tokenizePath(System.getProperty("java.class.path"))) {
                    File module = new File(s);
                    File cluster = module.getParentFile().getParentFile();
                    File m = new File(new File(cluster, "config"), "Modules");
                    if (m.exists() || cluster.getName().equals("cluster")) {
                        clusters.add(cluster);
                    }
                }
            }
            return clusters.toArray(new File[0]);
        }

        private static String cnb(Manifest m) {
            String cn = m.getMainAttributes().getValue("OpenIDE-Module");
            return cn != null ? cn.replaceFirst("/\\d+", "") : null;
        }
        
        /** 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();
                InputStream is = url.openStream();
                try {
                    String cnb = cnb(new Manifest(is));
                    if (cnb != null) {
                        cnbs.add(cnb);
                    }
                } finally {
                    is.close();
                }
            }

            return cnbs;
        }
        private static final Set<String> pseudoModules = new HashSet<String>(Arrays.asList(
                "org.openide.util",
                "org.openide.util.ui",
                "org.openide.util.lookup",
                "org.openide.modules",
                "org.netbeans.bootstrap",
                "org.openide.filesystems",
                "org.openide.filesystems.compat8",
                "org.netbeans.core.startup",
                "org.netbeans.core.startup.base",
                "org.netbeans.libs.asm"));
        static void turnClassPathModules(File ud, ClassLoader loader) throws IOException {
            Enumeration<URL> en = loader.getResources("META-INF/MANIFEST.MF");
            while (en.hasMoreElements()) {
                URL url = en.nextElement();
                Manifest m;
                InputStream is = url.openStream();
                try {
                    m = new Manifest(is);
                } catch (IOException x) {
                    throw new IOException("parsing " + url + ": " + x, x);
                } finally {
                    is.close();
                }
                String cnb = cnb(m);
                if (cnb != null) {
                    File jar = jarFromURL(url);
                    if (jar == null) {
                        continue;
                    }
                    if (pseudoModules.contains(cnb)) {
                        // Otherwise will get DuplicateException.
                        continue;
                    }
                    String mavenCP = m.getMainAttributes().getValue("Maven-Class-Path");
                    if (mavenCP != null) {
                        // Do not use ((URLClassLoader) loader).getURLs() as this does not work for Surefire Booter.
                        jar = rewrite(jar, mavenCP.split(" "), System.getProperty("java.class.path"));
                    }
                    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=\"" + cnb + "\">\n" +
"    <param name=\"autoload\">false</param>\n" +
"    <param name=\"eager\">false</param>\n" +
"    <param name=\"enabled\">true</param>\n" +
"    <param name=\"jar\">" + jar + "</param>\n" +
"    <param name=\"reloadable\">false</param>\n" +
"</module>\n";
                    
                    File conf = new File(new File(ud, "config"), "Modules");
                    conf.mkdirs();
                    File f = new File(conf, cnb.replace('.', '-') + ".xml");
                    writeModule(f, xml);
                }
            }
        }
        private static File rewrite(File jar, String[] mavenCP, String classpath) throws IOException { // #190992
            String[] classpathEntries = tokenizePath(classpath);
            StringBuilder classPathHeader = new StringBuilder();
            for (String artifact : mavenCP) {
                String[] grpArtVers = artifact.split(":");
                String partOfPath = File.separatorChar + grpArtVers[0].replace('.', File.separatorChar) + File.separatorChar + grpArtVers[1] + File.separatorChar + grpArtVers[2] + File.separatorChar + grpArtVers[1] + '-' + grpArtVers[2];
                File dep = null;
                for (String classpathEntry : classpathEntries) {
                    if (classpathEntry.endsWith(".jar") && classpathEntry.contains(partOfPath)) {
                        dep = new File(classpathEntry);
                        break;
                    }
                }
                if (dep == null) {
                    throw new IOException("no match for " + artifact + " found in " + classpath);
                }
                File depCopy = File.createTempFile(artifact.replace(':', '-') + '-', ".jar");
                depCopy.deleteOnExit();
                NbTestCase.copytree(dep, depCopy);
                if (classPathHeader.length() > 0) {
                    classPathHeader.append(' ');
                }
                classPathHeader.append(depCopy.getName());
            }
            String n = jar.getName();
            int dot = n.lastIndexOf('.');
            File jarCopy = File.createTempFile(n.substring(0, dot) + '-', n.substring(dot));
            jarCopy.deleteOnExit();
            InputStream is = new FileInputStream(jar);
            try {
                OutputStream os = new FileOutputStream(jarCopy);
                try {
                    JarInputStream jis = new JarInputStream(is);
                    Manifest mani = new Manifest(jis.getManifest());
                    mani.getMainAttributes().putValue("Class-Path", classPathHeader.toString());
                    JarOutputStream jos = new JarOutputStream(os, mani);
                    JarEntry entry;
                    while ((entry = jis.getNextJarEntry()) != null) {
                        if (entry.getName().matches("META-INF/.+[.]SF")) {
                            throw new IOException("cannot handle signed JARs");
                        }
                        jos.putNextEntry(entry);
                        byte[] buf = new byte[4092];
                        for (;;) {
                            int more = jis.read(buf, 0, buf.length);
                            if (more == -1) {
                                break;
                            }
                            jos.write(buf, 0, more);
                        }
                    }
                    jis.close();
                    jos.close();
                } finally {
                    os.close();
                }
            } finally {
                is.close();
            }
            return jarCopy;
        }
        
        private static Pattern MANIFEST = Pattern.compile("jar:(file:.*)!/META-INF/MANIFEST.MF", Pattern.MULTILINE);
        private static File jarFromURL(URL u) {
            Matcher m = MANIFEST.matcher(u.toExternalForm());
            if (m.matches()) {
                return toFile(URI.create(m.group(1)));
            } else {
                if (!u.getProtocol().equals("file")) {
                    throw new IllegalStateException(u.toExternalForm());
                } else {
                    return null;
                }
            }
        }

        /**
         * JDK 7
         */
        private static Method fileToPath, pathToUri, pathsGet, pathToFile;

        static {
            try {
                fileToPath = File.class.getMethod("toPath");
            } catch (NoSuchMethodException x) {
                // fine, JDK 6
            }
            if (fileToPath != null) {
                try {
                    Class<?> path = Class.forName("java.nio.file.Path");
                    pathToUri = path.getMethod("toUri");
                    pathsGet = Class.forName("java.nio.file.Paths").getMethod("get", URI.class);
                    pathToFile = path.getMethod("toFile");
                } catch (Exception x) {
                    throw new ExceptionInInitializerError(x);
                }
            }
        }
        private static File toFile(URI u) throws IllegalArgumentException {
            if (pathsGet != null) {
                try {
                    return (File) pathToFile.invoke(pathsGet.invoke(null, u));
                } catch (Exception x) {
                    LOG.log(Level.FINE, "could not convert " + u + " to File", x);
                }
            }
            String host = u.getHost();
            if (host != null && !host.isEmpty() && "file".equals(u.getScheme())) {
                return new File("\\\\" + host + u.getPath().replace('/', '\\'));
            }
            return new File(u);
        }
        private static URI toURI(File f) {
            if (fileToPath != null) {
                try {
                    URI u = (URI) pathToUri.invoke(fileToPath.invoke(f));
                    if (u.toString().startsWith("file:///")) { // #214131 workaround
                        u = new URI(/* "file" */u.getScheme(), /* null */u.getUserInfo(), /* null (!) */u.getHost(), /* -1 */u.getPort(), /* "/..." */u.getPath(), /* null */u.getQuery(), /* null */u.getFragment());
                    }
                    return u;
                } catch (Exception x) {
                    LOG.log(Level.FINE, "could not convert " + f + " to URI", x);
                }
            }
            String path = f.getAbsolutePath();
            if (path.startsWith("\\\\")) { // UNC
                if (!path.endsWith("\\") && f.isDirectory()) {
                    path += "\\";
                }
                try {
                    return new URI("file", null, path.replace('\\', '/'), null);
                } catch (URISyntaxException x) {
                    LOG.log(Level.FINE, "could not convert " + f + " to URI", x);
                }
            }
            return f.toURI();
        }
        
        static void preparePatches(String path, Properties prop, Class<?>... classes) throws URISyntaxException {
            Pattern tests = Pattern.compile(".*\\" + File.separator + "([^\\" + File.separator + "]+)\\" + File.separator + "tests\\.jar");
            StringBuilder sb = new StringBuilder();
            String sep = "";
            for (String jar : tokenizePath(path)) {
                Matcher m = tests.matcher(jar);
                if (m.matches()) {
                    // in case we need it one day, let's add a switch to Configuration
                    // and choose the following line instead of netbeans.systemclassloader.patches
                    // prop.setProperty("netbeans.patches." + m.group(1).replace('-', '.'), jar);
                    sb.append(sep).append(jar);
                    sep = File.pathSeparator;
                }
            }
            Set<URL> uniqueURLs = new HashSet<URL>();
            for (Class<?> c : classes) {
                URL test = c.getProtectionDomain().getCodeSource().getLocation();
                Assert.assertNotNull("URL found for " + c, test);
                if (uniqueURLs.add(test)) {
                    sb.append(sep).append(toFile(test.toURI()).getPath());
                    sep = File.pathSeparator;
                }
            }
            prop.setProperty("netbeans.systemclassloader.patches", sb.toString());
        }

        private static String asString(InputStream is, boolean close) throws IOException {
            StringBuilder builder = new StringBuilder();

            byte[] bytes = new byte[4096];
            try {
                for (int i; (i = is.read(bytes)) != -1;) {
                    builder.append(new String(bytes, 0, i, "UTF-8"));
                }
            } finally {
                if (close) {
                    is.close();
                }
            }
            for (;;) {
                int index = builder.indexOf("\r\n");
                if (index == -1) {
                    break;
                }
                builder.deleteCharAt(index);
            }
            return builder.toString();
        }

        private void disableModules(File ud, File cluster) throws IOException {
            File confDir = new File(new File(cluster, "config"), "Modules");
            for (File c : confDir.listFiles()) {
                if (!isModuleEnabled(c)) {
                    continue;
                }
                File udC = new File(new File(new File(ud, "config"), "Modules"), c.getName());
                if (!udC.exists()) {
                    File hidden = new File(udC.getParentFile(), c.getName() + "_hidden");
                    hidden.createNewFile();
                }
            }
        }
        
        private static boolean isModuleEnabled(File config) throws IOException {
            String xml = asString(new FileInputStream(config), true);
            Matcher matcherEnabled = ENABLED.matcher(xml);
            if (matcherEnabled.find()) {
                return "true".equals(matcherEnabled.group(1));
            }
            return false;
        }

        private static class Shutdown extends NbTestCase {
            Shutdown(ClassLoader global, String testClass) throws Exception {
                super("shuttingDown[" + testClass + "]");
                this.global = global;
            }

            @Override
            protected int timeOut() {
                return 180000; // 3 minutes for a shutdown
            }

            @Override
            protected Level logLevel() {
                return Level.FINE;
            }

            @Override
            protected String logRoot() {
                return "org.netbeans.core.NbLifecycleManager"; // NOI18N
            }
            
            private static void waitForAWT() throws InvocationTargetException, InterruptedException {
                final CountDownLatch cdl = new CountDownLatch(1);
                SwingUtilities.invokeLater(new Runnable() {
                    public @Override void run() {
                        cdl.countDown();
                    }
                });
                cdl.await(10, TimeUnit.SECONDS);
            }
            private final ClassLoader global;

            @Override
            protected void runTest() throws Throwable {
                JFrame shutDown;
                try {
                    shutDown = new JFrame("Shutting down NetBeans...");
                    shutDown.setBounds(new Rectangle(-100, -100, 50, 50));
                    shutDown.setVisible(true);
                } catch (HeadlessException ex) {
                    shutDown = null;
                }
                
                Class<?> lifeClazz = global.loadClass("org.openide.LifecycleManager"); // NOI18N
                Method getDefault = lifeClazz.getMethod("getDefault"); // NOI18N
                Method exit = lifeClazz.getMethod("exit");
                LOG.log(Level.FINE, "Closing via LifecycleManager loaded by {0}", lifeClazz.getClassLoader());
                Object life = getDefault.invoke(null);
                if (!life.getClass().getName().startsWith("org.openide.LifecycleManager")) { // NOI18N
                    System.setProperty("netbeans.close.no.exit", "true"); // NOI18N
                    System.setProperty("netbeans.close", "true"); // NOI18N
                    exit.invoke(life);
                    waitForAWT();
                    System.getProperties().remove("netbeans.close"); // NOI18N
                    System.getProperties().remove("netbeans.close.no.exit"); // NOI18N
                }
                
                if (shutDown != null) {
                    shutDown.setVisible(false);
                }
            }
        }
        

        private static final class JUnitLoader extends ClassLoader {
            private final ClassLoader junit;

            public JUnitLoader(ClassLoader parent, ClassLoader junit) {
                super(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);
                }
                if (name.equals("META-INF/services/java.util.logging.Handler")) { // NOI18N
                    return junit.getResource("org/netbeans/junit/internal/FakeMetaInf.txt"); // NOI18N
                }
                return super.findResource(name);
            }

            @Override
            public Enumeration<URL> findResources(String name) throws IOException {
                if (isUnit(name)) {
                    return junit.getResources(name);
                }
                if (name.equals("META-INF/services/java.util.logging.Handler")) { // NOI18N
                    return junit.getResources("org/netbeans/junit/internal/FakeMetaInf.txt"); // NOI18N
                }
                return super.findResources(name);
            }

            private 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")) {
                    if (res.startsWith("org.netbeans.junit.ide") || res.startsWith("org/netbeans/junit/ide")) {
                        return false;
                    }
                    return true;
                }
                return false;
            }
        }

        private static Pattern ENABLED = Pattern.compile("<param name=[\"']enabled[\"']>([^<]*)</param>", Pattern.MULTILINE);
        private static Pattern AUTO = Pattern.compile("<param name=[\"']autoload[\"']>([^<]*)</param>", Pattern.MULTILINE);
        private static Pattern EAGER = Pattern.compile("<param name=[\"']eager[\"']>([^<]*)</param>", Pattern.MULTILINE);
        
        private static void turnModules(File ud, boolean autoloads, TreeSet<String> modules, List<String> regExp, File... clusterDirs) throws IOException {
            if (regExp == null) {
                return;
            }
            File config = new File(new File(ud, "config"), "Modules");
            config.mkdirs();

            Iterator<String> it = regExp.iterator();
            for (;;) {
                if (!it.hasNext()) {
                    break;
                }
                String clusterReg = it.next();
                String moduleReg = it.next();
                Pattern modPattern = Pattern.compile(moduleReg);
                for (File c : clusterDirs) {
                    if (!c.getName().matches(clusterReg)) {
                        continue;
                    }

                    File modulesDir = new File(new File(c, "config"), "Modules");
                    File[] allModules = modulesDir.listFiles();
                    if (allModules == null) {
                        continue;
                    }
                    for (File m : allModules) {
                        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);

                        boolean contains = modules.contains(n);
                        if (!contains && modPattern != null) {
                            contains = modPattern.matcher(n).matches();
                        }
                        if (!contains) {
                            continue;
                        }
                        enableModule(xml, autoloads, contains, new File(config, m.getName()));
                    }
                }
            }
        }
        
        private static void enableModule(String xml, boolean autoloads, boolean enable, File target) throws IOException {
            boolean toEnable = false;
            {
                  Matcher matcherEnabled = ENABLED.matcher(xml);
                if (matcherEnabled.find()) {
                    toEnable = "false".equals(matcherEnabled.group(1));
                }
                Matcher matcherEager = EAGER.matcher(xml);
                if (matcherEager.find()) {
                    if ("true".equals(matcherEager.group(1))) {
                        return;
                    }
                }
                if (!autoloads) {
                    Matcher matcherAuto = AUTO.matcher(xml);
                    if (matcherAuto.find()) {
                        if ("true".equals(matcherAuto.group(1))) {
                            return;
                        }
                    }
                }
                if (toEnable) {
                    assert matcherEnabled.groupCount() == 1 : "Groups: " + matcherEnabled.groupCount() + " for:\n" + xml;
                    try {
                        String out = xml.substring(0, matcherEnabled.start(1)) + (enable ? "true" : "false") + xml.substring(matcherEnabled.end(1));
                        writeModule(target, out);
                    } catch (IllegalStateException ex) {
                        throw new IOException("Unparsable:\n" + xml, ex);
                    }
                }
            }
            {
                Matcher matcherEager = AUTO.matcher(xml);
                if (matcherEager.find()) {
                    int begin = xml.indexOf("<param name=\"autoload");
                    int end = xml.indexOf("<param name=\"jar");
                    String middle = "<param name=\"autoload\">false</param>\n" + "    <param name=\"eager\">false</param>\n" + "    <param name=\"enabled\">true</param>\n" + "    ";
                    String out = xml.substring(0, begin) + middle + xml.substring(end);
                    try {
                        writeModule(target, out);
                    } catch (IllegalStateException ex) {
                        throw new IOException("Unparsable:\n" + xml, ex);
                    }
                }
            }
        }

        private static void writeModule(File file, String xml) throws IOException {
            String previous;
            if (file.exists()) {
                previous = asString(new FileInputStream(file), true);
                if (previous.equals(xml)) {
                    return;
                }
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.log(Level.FINE, "rewrite module file: {0}", file);
                    charDump(Level.FINEST, previous);
                    LOG.finest("new----");
                    charDump(Level.FINEST, xml);
                    LOG.finest("end----");
                }
            }
            FileOutputStream os = new FileOutputStream(file);
            os.write(xml.getBytes("UTF-8"));
            os.close();
        }

        private static void charDump(Level logLevel, String text) {
            StringBuilder sb = new StringBuilder(5 * text.length());
            for (int i = 0; i < text.length(); i++) {
                if (i % 8 == 0) {
                    if (i > 0) {
                        sb.append('\n');
                    }
                } else {
                    sb.append(' ');
                }

                int ch = text.charAt(i);
                if (' ' <= ch && ch <= 'z') {
                    sb.append('\'').append((char)ch).append('\'');
                } else {
                    sb.append('x').append(two(Integer.toHexString(ch).toUpperCase()));
                }
            }
            sb.append('\n');
            LOG.log(logLevel, sb.toString());
        }

        private static String two(String s) {
            int len = s.length();
            switch (len) {
                case 0: return "00";
                case 1: return "0" + s;
                case 2: return s;
                default: return s.substring(len - 2);
            }
        }

    } // end of S

    private static class NbTestSuiteLogCheck extends NbTestSuite {
        public NbTestSuiteLogCheck() {
        }
        public NbTestSuiteLogCheck(Class<? extends TestCase> clazz) {
            super(clazz);
        }

        @Override
        public void runTest(Test test, TestResult result) {
            int e = result.errorCount();
            int f = result.failureCount();
            LOG.log(Level.FINE, "Running test {0}", test);
            super.runTest(test, result);
            LOG.log(Level.FINE, "Finished: {0}", test);
            if (e == result.errorCount() && f == result.failureCount()) {
                NbModuleLogHandler.checkFailures((TestCase) test, result, test instanceof NbTestCase ? ((NbTestCase) test).getWorkDirPath() : Manager.getWorkDirPath());
            }
        }
    }
}
