* The MIT License

*

* Copyright (c) 2004-2009, Sun Microsystems, Inc., Kohsuke Kawaguchi, Erik Ramfelt,

* Yahoo! Inc., Tom Huybrechts, Olivier Lamy

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

*/

* JUnit 4.10+ style rule to allow test cases to fire up a Jenkins instance

*

* @see <a href="http://wiki.jenkins-ci.org/display/JENKINS/Unit+Test+JUnit4">Wiki article about unit testing in Jenkins</a>

* @author Stephen Connolly

*/

    private final TestEnvironment env = new TestEnvironment(null);

    private Description testDescription;

    private static JenkinsRule CURRENT = null;

    /**

     * Points to the same object as {@link #jenkins} does.

     */

    public Hudson hudson;

    public Jenkins jenkins;

    protected HudsonHomeLoader homeLoader = HudsonHomeLoader.NEW;

    /**

     * TCP/IP port that the server is listening on.

     */

    protected int localPort;

    protected Server server;

    /**

     * Where in the {@link Server} is Hudson deployed?

     * <p>

     * Just like {@link javax.servlet.ServletContext#getContextPath()}, starts with '/' but doesn't end with '/'.

     */

    protected String contextPath = "";

    /**

     * {@link Runnable}s to be invoked at {@link #after()} .

     */

    protected List<LenientRunnable> tearDowns = new ArrayList<LenientRunnable>();

    protected List<JenkinsRecipe.Runner> recipes = new ArrayList<JenkinsRecipe.Runner>();

    /**

     * Remember {@link WebClient}s that are created, to release them properly.

     */

    private List<WebClient> clients = new ArrayList<WebClient>();

    /**

     * Remember channels that are created, to release them at the end.

     */

    private List<Channel> channels = new ArrayList<Channel>();

    /**

     * JavaScript "debugger" that provides you information about the JavaScript call stack

     * and the current values of the local variables in those stack frame.

     *

     * <p>

     * Unlike Java debugger, which you as a human interfaces directly and interactively,

     * this JavaScript debugger is to be interfaced by your program (or through the

     * expression evaluation capability of your Java debugger.)

     */

    protected JavaScriptDebugger jsDebugger = new JavaScriptDebugger();

    /**

     * If this test case has additional {@link org.jvnet.hudson.test.recipes.WithPlugin} annotations, set to true.

     * This will cause a fresh {@link hudson.PluginManager} to be created for this test.

     * Leaving this to false enables the test harness to use a pre-loaded plugin manager,

     * which runs faster.

     *

     * @deprecated

     *      Use {@link #pluginManager}

     */

    public boolean useLocalPluginManager;

    /**

     * Set the plugin manager to be passed to {@link Jenkins} constructor.

     *

     * For historical reasons, {@link #useLocalPluginManager}==true will take the precedence.

     */

    private PluginManager pluginManager = TestPluginManager.INSTANCE;

    public JenkinsComputerConnectorTester computerConnectorTester = new JenkinsComputerConnectorTester(this);

    public Jenkins getInstance() {

        return jenkins;

    }

    /**

     * Override to set up your specific external resource.

     * @throws Throwable if setup fails (which will disable {@code after}

     */

    protected void before() throws Throwable {

        env.pin();

        recipe();

        AbstractProject.WORKSPACE.toString();

        User.clear();

        try {

            jenkins = hudson = newHudson();

        } catch (Exception e) {

            // if Hudson instance fails to initialize, it leaves the instance field non-empty and break all the rest of the tests, so clean that up.

            Field f = Jenkins.class.getDeclaredField("theInstance");

            f.setAccessible(true);

            f.set(null,null);

            throw e;

        }

        hudson.setNoUsageStatistics(true); // collecting usage stats from tests are pointless.

        hudson.setCrumbIssuer(new TestCrumbIssuer());

        hudson.servletContext.setAttribute("app",hudson);

        hudson.servletContext.setAttribute("version","?");

        WebAppMain.installExpressionFactory(new ServletContextEvent(hudson.servletContext));

        // set a default JDK to be the one that the harness is using.

        hudson.getJDKs().add(new JDK("default",System.getProperty("java.home")));

        configureUpdateCenter();

        // expose the test instance as a part of URL tree.

        // this allows tests to use a part of the URL space for itself.

        hudson.getActions().add(this);

        // cause all the descriptors to reload.

        // ideally we'd like to reset them to properly emulate the behavior, but that's not possible.

        Mailer.DescriptorImpl desc = Mailer.descriptor();

        // prevent NPE with eclipse

        if (desc != null) Mailer.descriptor().setHudsonUrl(null);

        for( Descriptor d : hudson.getExtensionList(Descriptor.class) )

            d.load();

    }

    /**

     * Configures the update center setting for the test.

     * By default, we load updates from local proxy to avoid network traffic as much as possible.

     */

    protected void configureUpdateCenter() throws Exception {

        final String updateCenterUrl = "http://localhost:"+ JavaNetReverseProxy.getInstance().localPort+"/update-center.json";

        // don't waste bandwidth talking to the update center

        DownloadService.neverUpdate = true;

        UpdateSite.neverUpdate = true;

        PersistedList<UpdateSite> sites = hudson.getUpdateCenter().getSites();

        sites.clear();

        sites.add(new UpdateSite("default", updateCenterUrl));

    }

    /**

     * Override to tear down your specific external resource.

     */

    protected void after() {

        try {

            // cancel pending asynchronous operations, although this doesn't really seem to be working

            for (WebClient client : clients) {

                // unload the page to cancel asynchronous operations

                try {

                    client.getPage("about:blank");

                } catch (IOException e) {

                    // ignore

                }

                client.closeAllWindows();

            }

            clients.clear();

            for (Channel c : channels)

                try {

                    c.close();

                } catch (IOException e) {

                    // ignore

                }

            for (Channel c : channels)

                try {

                    c.join();

                } catch (InterruptedException e) {

                    // ignore

                }

            channels.clear();

        } finally {

            try {

                server.stop();

            } catch (Exception e) {

                // ignore

            }

            for (LenientRunnable r : tearDowns)

                try {

                    r.run();

                } catch (Exception e) {

                    // ignore

                }

            hudson.cleanUp();

            ExtensionList.clearLegacyInstances();

            DescriptorExtensionList.clearLegacyInstances();

            // Hudson creates ClassLoaders for plugins that hold on to file descriptors of its jar files,

            // but because there's no explicit dispose method on ClassLoader, they won't get GC-ed until

            // at some later point, leading to possible file descriptor overflow. So encourage GC now.

            // see http://bugs.sun.com/view_bug.do?bug_id=4950148

            System.gc();

        }

    }

    public Statement apply(final Statement base, final Description description) {

        if (description.getAnnotation(WithoutJenkins.class) != null) {

            // request has been made to not create the instance for this test method

            return base;

        }

        return new Statement() {

            @Override

            public void evaluate() throws Throwable {

                testDescription = description;

                Thread t = Thread.currentThread();

                String o = t.getName();

                t.setName("Executing "+ testDescription.getDisplayName());

                CURRENT = JenkinsRule.this;

                before();

                try {

                    System.out.println("=== Starting " + testDescription.getDisplayName());

                    // so that test code has all the access to the system

                    ACL.impersonate(ACL.SYSTEM);

                    try {

                        base.evaluate();

                    } catch (Throwable th) {

                        // allow the late attachment of a debugger in case of a failure. Useful

                        // for diagnosing a rare failure

                        try {

                            throw new BreakException();

                        } catch (BreakException e) {}

                        // dump threads

                        ThreadInfo[] threadInfos = Functions.getThreadInfos();

                        Functions.ThreadGroupMap m = Functions.sortThreadsAndGetGroupMap(threadInfos);

                        for (ThreadInfo ti : threadInfos) {

                            System.err.println(Functions.dumpThreadInfo(ti, m));

                        }

                        throw th;

                    }

                } finally {

                    after();

                    testDescription = null;

                    t.setName(o);

                    CURRENT = null;

                }

            }

        };

    }

    public static class BreakException extends Exception {}

    public String getIconFileName() {

        return null;

    }

    public String getDisplayName() {

        return null;

    }

    public String getUrlName() {

        return "self";

    }

    /**

     * Creates a new instance of {@link jenkins.model.Jenkins}. If the derived class wants to create it in a different way,

     * you can override it.

     */

    protected Hudson newHudson() throws Exception {

        ServletContext webServer = createWebServer();

        File home = homeLoader.allocate();

        for (JenkinsRecipe.Runner r : recipes)

            r.decorateHome(this,home);

        return new Hudson(home, webServer, getPluginManager());

    }

    public PluginManager getPluginManager() {

        if (hudson == null) {

            return useLocalPluginManager ? null : pluginManager;

        } else {

            return hudson.getPluginManager();

        }

    }

    /**

     * Sets the {@link PluginManager} to be used when creating a new {@link Jenkins} instance.

     *

     * @param pluginManager

     *      null to let Jenkins create a new instance of default plugin manager, like it normally does when running as a webapp outside the test.

     */

    public void setPluginManager(PluginManager pluginManager) {

        this.useLocalPluginManager = false;

        this.pluginManager = pluginManager;

        if (hudson!=null)

            throw new IllegalStateException("Too late to override the plugin manager");

    }

    public JenkinsRule with(PluginManager pluginManager) {

        setPluginManager(pluginManager);

        return this;

    }

    public File getWebAppRoot() throws Exception {

        return WarExploder.getExplodedDir();

    }

    /**

     * Prepares a webapp hosting environment to get {@link javax.servlet.ServletContext} implementation

     * that we need for testing.

     */

    protected ServletContext createWebServer() throws Exception {

        server = new Server();

        WebAppContext context = new WebAppContext(WarExploder.getExplodedDir().getPath(), contextPath);

        context.setClassLoader(getClass().getClassLoader());

        context.setConfigurations(new Configuration[]{new WebXmlConfiguration(), new NoListenerConfiguration()});

        server.setHandler(context);

        context.setMimeTypes(MIME_TYPES);

        SocketConnector connector = new SocketConnector();

        connector.setHeaderBufferSize(12*1024); // use a bigger buffer as Stapler traces can get pretty large on deeply nested URL

        server.setThreadPool(new ThreadPoolImpl(new ThreadPoolExecutor(10, 10, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),new ThreadFactory() {

            public Thread newThread(Runnable r) {

                Thread t = new Thread(r);

                t.setName("Jetty Thread Pool");

                return t;

            }

        })));

        server.addConnector(connector);

        server.addUserRealm(configureUserRealm());

        server.start();

        localPort = connector.getLocalPort();

        return context.getServletContext();

    }

    /**

     * Configures a security realm for a test.

     */

    protected UserRealm configureUserRealm() {

        HashUserRealm realm = new HashUserRealm();

        realm.setName("default");   // this is the magic realm name to make it effective on everywhere

        realm.put("alice","alice");

        realm.put("bob","bob");

        realm.put("charlie","charlie");

        realm.addUserToRole("alice","female");

        realm.addUserToRole("bob","male");

        realm.addUserToRole("charlie","male");

        return realm;

    }

    @TestExtension

    public static class ComputerListenerImpl extends ComputerListener {

        @Override

        public void onOnline(Computer c, TaskListener listener) throws IOException, InterruptedException {

            VirtualChannel ch = c.getChannel();

            if (ch instanceof Channel)

                CURRENT.channels.add((Channel)ch);

        }

    }

//     * Sets guest credentials to access java.net Subversion repo.

//     */

//    protected void setJavaNetCredential() throws SVNException, IOException {

//        // set the credential to access svn.dev.java.net

//        hudson.getDescriptorByType(SubversionSCM.DescriptorImpl.class).postCredential("https://svn.dev.java.net/svn

// /hudson/","guest","",null,new PrintWriter(new NullStream()));

//    }

    /**

     * Returns the older default Maven, while still allowing specification of other bundled Mavens.

     */

    protected Maven.MavenInstallation configureDefaultMaven() throws Exception {

        return configureDefaultMaven("apache-maven-2.2.1", Maven.MavenInstallation.MAVEN_20);

    }

    protected Maven.MavenInstallation configureMaven3() throws Exception {

        Maven.MavenInstallation mvn = configureDefaultMaven("apache-maven-3.0.1", Maven.MavenInstallation.MAVEN_30);

        Maven.MavenInstallation m3 = new Maven.MavenInstallation("apache-maven-3.0.1",mvn.getHome(), NO_PROPERTIES);

        hudson.getDescriptorByType(Maven.DescriptorImpl.class).setInstallations(m3);

        return m3;

    }

    /**

     * Locates Maven2 and configure that as the only Maven in the system.

     */

    protected Maven.MavenInstallation configureDefaultMaven(String mavenVersion, int mavenReqVersion) throws Exception {

        // first if we are running inside Maven, pick that Maven, if it meets the criteria we require..

        // does it exists in the buildDirectory see maven-junit-plugin systemProperties

        // buildDirectory -> ${project.build.directory} (so no reason to be null ;-) )

        String buildDirectory = System.getProperty( "buildDirectory", "./target/classes/" );

        File mavenAlreadyInstalled = new File(buildDirectory, mavenVersion);

        if (mavenAlreadyInstalled.exists()) {

            Maven.MavenInstallation

                    mavenInstallation = new Maven.MavenInstallation("default",mavenAlreadyInstalled.getAbsolutePath(), NO_PROPERTIES);

            hudson.getDescriptorByType(Maven.DescriptorImpl.class).setInstallations(mavenInstallation);

            return mavenInstallation;

        }

        String home = System.getProperty("maven.home");

        if(home!=null) {

            Maven.MavenInstallation mavenInstallation = new Maven.MavenInstallation("default",home, NO_PROPERTIES);

            if (mavenInstallation.meetsMavenReqVersion(createLocalLauncher(), mavenReqVersion)) {

                hudson.getDescriptorByType(Maven.DescriptorImpl.class).setInstallations(mavenInstallation);

                return mavenInstallation;

            }

        }

        // otherwise extract the copy we have.

        // this happens when a test is invoked from an IDE, for example.

        LOGGER.warning("Extracting a copy of Maven bundled in the test harness. " +

                "To avoid a performance hit, set the system property 'maven.home' to point to a Maven2 installation.");

        FilePath mvn = hudson.getRootPath().createTempFile("maven", "zip");

        mvn.copyFrom(HudsonTestCase.class.getClassLoader().getResource(mavenVersion + "-bin.zip"));

        File mvnHome =  new File(buildDirectory);//createTmpDir();

        mvn.unzip(new FilePath(mvnHome));

        // TODO: switch to tar that preserves file permissions more easily

        if(!Functions.isWindows())

            GNUCLibrary.LIBC.chmod(new File(mvnHome,mavenVersion+"/bin/mvn").getPath(),0755);

        Maven.MavenInstallation mavenInstallation = new Maven.MavenInstallation("default",

                new File(mvnHome,mavenVersion).getAbsolutePath(), NO_PROPERTIES);

    hudson.getDescriptorByType(Maven.DescriptorImpl.class).setInstallations(mavenInstallation);

    return mavenInstallation;

    }

    /**

     * Extracts Ant and configures it.

     */

    protected Ant.AntInstallation configureDefaultAnt() throws Exception {

        Ant.AntInstallation antInstallation;

        if (System.getenv("ANT_HOME") != null) {

            antInstallation = new Ant.AntInstallation("default", System.getenv("ANT_HOME"), NO_PROPERTIES);

        } else {

            LOGGER.warning("Extracting a copy of Ant bundled in the test harness. " +

                    "To avoid a performance hit, set the environment variable ANT_HOME to point to an  Ant installation.");

            FilePath ant = hudson.getRootPath().createTempFile("ant", "zip");

            ant.copyFrom(HudsonTestCase.class.getClassLoader().getResource("apache-ant-1.8.1-bin.zip"));

            File antHome = createTmpDir();

            ant.unzip(new FilePath(antHome));

            // TODO: switch to tar that preserves file permissions more easily

            if(!Functions.isWindows())

                GNUCLibrary.LIBC.chmod(new File(antHome,"apache-ant-1.8.1/bin/ant").getPath(),0755);

            antInstallation = new Ant.AntInstallation("default", new File(antHome,"apache-ant-1.8.1").getAbsolutePath(),NO_PROPERTIES);

        }

    hudson.getDescriptorByType(Ant.DescriptorImpl.class).setInstallations(antInstallation);

    return antInstallation;

    }

// Convenience methods

//

    protected FreeStyleProject createFreeStyleProject() throws IOException {

        return createFreeStyleProject(createUniqueProjectName());

    }

    protected FreeStyleProject createFreeStyleProject(String name) throws IOException {

        return hudson.createProject(FreeStyleProject.class, name);

    }

    protected MatrixProject createMatrixProject() throws IOException {

        return createMatrixProject(createUniqueProjectName());

    }

    protected MatrixProject createMatrixProject(String name) throws IOException {

        return hudson.createProject(MatrixProject.class, name);

    }

    /**

     * Creates a empty Maven project with an unique name.

     *

     * @see #configureDefaultMaven()

     */

    protected MavenModuleSet createMavenProject() throws IOException {

        return createMavenProject(createUniqueProjectName());

    }

    /**

     * Creates a empty Maven project with the given name.

     *

     * @see #configureDefaultMaven()

     */

    protected MavenModuleSet createMavenProject(String name) throws IOException {

        return hudson.createProject(MavenModuleSet.class,name);

    }

    private String createUniqueProjectName() {

        return "test"+hudson.getItems().size();

    }

    /**

     * Creates {@link hudson.Launcher.LocalLauncher}. Useful for launching processes.

     */

    protected Launcher.LocalLauncher createLocalLauncher() {

        return new Launcher.LocalLauncher(StreamTaskListener.fromStdout());

    }

    /**

     * Allocates a new temporary directory for the duration of this test.

     */

    public File createTmpDir() throws IOException {

        return env.temporaryDirectoryAllocator.allocate();

    }

    public DumbSlave createSlave() throws Exception {

        return createSlave("",null);

    }

    /**

     * Creates and launches a new slave on the local host.

     */

    public DumbSlave createSlave(Label l) throws Exception {

      return createSlave(l, null);

    }

    /**

     * Creates a test {@link hudson.security.SecurityRealm} that recognizes username==password as valid.

     */

    public SecurityRealm createDummySecurityRealm() {

        return new AbstractPasswordBasedSecurityRealm() {

            @Override

            protected UserDetails authenticate(String username, String password) throws AuthenticationException {

                if (username.equals(password))

                    return loadUserByUsername(username);

                throw new BadCredentialsException(username);

            }

            @Override

            public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException,

                    DataAccessException {

                return new org.acegisecurity.userdetails.User(username,"",true,true,true,true,new GrantedAuthority[]{AUTHENTICATED_AUTHORITY});

            }

            @Override

            public GroupDetails loadGroupByGroupname(String groupname) throws UsernameNotFoundException, DataAccessException {

                throw new UsernameNotFoundException(groupname);

            }

        };

    }

    /**

     * Returns the URL of the webapp top page.

     * URL ends with '/'.

     */

    public URL getURL() throws IOException {

        return new URL("http://localhost:"+localPort+contextPath+"/");

    }

    public DumbSlave createSlave(EnvVars env) throws Exception {

        return createSlave("",env);

    }

    public DumbSlave createSlave(Label l, EnvVars env) throws Exception {

        return createSlave(l==null ? null : l.getExpression(), env);

    }

    /**

     * Creates a slave with certain additional environment variables

     */

    public DumbSlave createSlave(String labels, EnvVars env) throws Exception {

        synchronized (hudson) {

            int sz = hudson.getNodes().size();

            return createSlave("slave" + sz,labels,env);

      }

    }

    public DumbSlave createSlave(String nodeName, String labels, EnvVars env) throws Exception {

        synchronized (hudson) {

            DumbSlave slave = new DumbSlave(nodeName, "dummy",

            createTmpDir().getPath(), "1", Node.Mode.NORMAL, labels==null?"":labels, createComputerLauncher(env), RetentionStrategy.NOOP, Collections.EMPTY_LIST);

        hudson.addNode(slave);

        return slave;

      }

    }

    public PretendSlave createPretendSlave(FakeLauncher faker) throws Exception {

        synchronized (hudson) {

            int sz = hudson.getNodes().size();

            PretendSlave slave = new PretendSlave("slave" + sz, createTmpDir().getPath(), "", createComputerLauncher(null), faker);

        hudson.addNode(slave);

        return slave;

        }

    }

    /**

     * Creates a {@link hudson.slaves.CommandLauncher} for launching a slave locally.

     *

     * @param env

     *      Environment variables to add to the slave process. Can be null.

     */

    public CommandLauncher createComputerLauncher(EnvVars env) throws URISyntaxException, MalformedURLException {

        int sz = hudson.getNodes().size();

        return new CommandLauncher(

                String.format("\"%s/bin/java\" %s -jar \"%s\"",

                        System.getProperty("java.home"),

                        SLAVE_DEBUG_PORT>0 ? " -Xdebug -Xrunjdwp:transport=dt_socket,server=y,address="+(SLAVE_DEBUG_PORT+sz): "",

                        new File(hudson.getJnlpJars("slave.jar").getURL().toURI()).getAbsolutePath()),

                env);

    }

    /**

     * Create a new slave on the local host and wait for it to come onilne

     * before returning.

     */

    public DumbSlave createOnlineSlave() throws Exception {

        return createOnlineSlave(null);

    }

    /**

     * Create a new slave on the local host and wait for it to come onilne

     * before returning.

     */

    public DumbSlave createOnlineSlave(Label l) throws Exception {

        return createOnlineSlave(l, null);

    }

    /**

     * Create a new slave on the local host and wait for it to come online

     * before returning

     */

    @SuppressWarnings({"deprecation"})

    public DumbSlave createOnlineSlave(Label l, EnvVars env) throws Exception {

        final CountDownLatch latch = new CountDownLatch(1);

        ComputerListener waiter = new ComputerListener() {

                                            @Override

                                            public void onOnline(Computer C, TaskListener t) {

                                                latch.countDown();

                                                unregister();

                                            }

                                        };

        waiter.register();

        DumbSlave s = createSlave(l, env);

        latch.await();

        return s;

    }

    /**

     * Blocks until the ENTER key is hit.

     * This is useful during debugging a test so that one can inspect the state of Hudson through the web browser.

     */

    public void interactiveBreak() throws Exception {

        System.out.println("Jenkins is running at http://localhost:"+localPort+"/");

        new BufferedReader(new InputStreamReader(System.in)).readLine();

    }

    /**

     * Returns the last item in the list.

     */

    protected <T> T last(List<T> items) {

        return items.get(items.size()-1);

    }

    /**

     * Pauses the execution until ENTER is hit in the console.

     * <p>

     * This is often very useful so that you can interact with Hudson

     * from an browser, while developing a test case.

     */

    protected void pause() throws IOException {

        new BufferedReader(new InputStreamReader(System.in)).readLine();

    }

    /**

     * Performs a search from the search box.

     */

    protected Page search(String q) throws Exception {

        return new WebClient().search(q);

    }

    /**

     * Hits the Hudson system configuration and submits without any modification.

     */

    protected void configRoundtrip() throws Exception {

        submit(createWebClient().goTo("configure").getFormByName("config"));

    }

    /**

     * Loads a configuration page and submits it without any modifications, to

     * perform a round-trip configuration test.

     * <p>

     * See http://wiki.jenkins-ci.org/display/JENKINS/Unit+Test#UnitTest-Configurationroundtriptesting

     */

    protected <P extends Job> P configRoundtrip(P job) throws Exception {

        submit(createWebClient().getPage(job,"configure").getFormByName("config"));

        return job;

    }

    protected <P extends Item> P configRoundtrip(P job) throws Exception {

        submit(createWebClient().getPage(job, "configure").getFormByName("config"));

        return job;

    }

    /**

     * Performs a configuration round-trip testing for a builder.

     */

    protected <B extends Builder> B configRoundtrip(B before) throws Exception {

        FreeStyleProject p = createFreeStyleProject();

        p.getBuildersList().add(before);

        configRoundtrip((Item)p);

        return (B)p.getBuildersList().get(before.getClass());

    }

    /**

     * Performs a configuration round-trip testing for a publisher.

     */

    protected <P extends Publisher> P configRoundtrip(P before) throws Exception {

        FreeStyleProject p = createFreeStyleProject();

        p.getPublishersList().add(before);

        configRoundtrip((Item) p);

        return (P)p.getPublishersList().get(before.getClass());

    }

    protected <C extends ComputerConnector> C configRoundtrip(C before) throws Exception {

        computerConnectorTester.connector = before;

        submit(createWebClient().goTo("self/computerConnectorTester/configure").getFormByName("config"));

        return (C)computerConnectorTester.connector;

    }

    protected User configRoundtrip(User u) throws Exception {

        submit(createWebClient().goTo(u.getUrl()+"/configure").getFormByName("config"));

        return u;

    }

    protected <N extends Node> N configRoundtrip(N node) throws Exception {

        submit(createWebClient().goTo("/computer/" + node.getNodeName() + "/configure").getFormByName("config"));

        return (N)hudson.getNode(node.getNodeName());

    }

    protected <V extends View> V configRoundtrip(V view) throws Exception {

        submit(createWebClient().getPage(view, "configure").getFormByName("viewConfig"));

        return view;

    }

    /**

     * Asserts that the outcome of the build is a specific outcome.

     */

    public <R extends Run> R assertBuildStatus(Result status, R r) throws Exception {

        if(status==r.getResult())

            return r;

        // dump the build output in failure message

        String msg = "unexpected build status; build log was:\n------\n" + getLog(r) + "\n------\n";

        if(r instanceof MatrixBuild) {

            MatrixBuild mb = (MatrixBuild)r;

            for (MatrixRun mr : mb.getRuns()) {

                msg+="--- "+mr.getParent().getCombination()+" ---\n"+getLog(mr)+"\n------\n";

            }

        }

        assertThat(msg, r.getResult(), is(status));

        return r;

    }

    /** Determines whether the specifed HTTP status code is generally "good" */

    public boolean isGoodHttpStatus(int status) {

        if ((400 <= status) && (status <= 417)) {

            return false;

        }

        if ((500 <= status) && (status <= 505)) {

            return false;

        }

        return true;

    }

    /** Assert that the specifed page can be served with a "good" HTTP status,

     * eg, the page is not missing and can be served without a server error

     * @param page

     */

    public void assertGoodStatus(Page page) {

        assertThat(isGoodHttpStatus(page.getWebResponse().getStatusCode()), is(true));

    }

    public <R extends Run> R assertBuildStatusSuccess(R r) throws Exception {

        assertBuildStatus(Result.SUCCESS, r);

        return r;

    }

    public <R extends Run> R assertBuildStatusSuccess(Future<? extends R> r) throws Exception {

        assertThat("build was actually scheduled", r, Matchers.notNullValue());

        return assertBuildStatusSuccess(r.get());

    }

    public <J extends AbstractProject<J,R>,R extends AbstractBuild<J,R>> R buildAndAssertSuccess(J job) throws Exception {

        return assertBuildStatusSuccess(job.scheduleBuild2(0));

    }

    /**

     * Avoids need for cumbersome {@code this.<J,R>buildAndAssertSuccess(...)} type hints under JDK 7 javac (and supposedly also IntelliJ).

     */

    public FreeStyleBuild buildAndAssertSuccess(FreeStyleProject job) throws Exception {

        return assertBuildStatusSuccess(job.scheduleBuild2(0));

    }

    public MavenModuleSetBuild buildAndAssertSuccess(MavenModuleSet job) throws Exception {

        return assertBuildStatusSuccess(job.scheduleBuild2(0));

    }

    public MavenBuild buildAndAssertSuccess(MavenModule job) throws Exception {

        return assertBuildStatusSuccess(job.scheduleBuild2(0));

    }

    /**

     * Asserts that the console output of the build contains the given substring.

     */

    public void assertLogContains(String substring, Run run) throws Exception {

        assertThat(getLog(run), containsString(substring));

    }

    /**

     * Get entire log file (this method is deprecated in hudson.model.Run,

     * but in tests it is OK to load entire log).

     */

    protected static String getLog(Run run) throws IOException {

        return Util.loadFile(run.getLogFile(), run.getCharset());

    }

    /**

     * Asserts that the XPath matches.

     */

    public void assertXPath(HtmlPage page, String xpath) {

        assertThat(page.getDocumentElement(), hasXPath(xpath));

    }

    /** Asserts that the XPath matches the contents of a DomNode page. This