staxtestcaseactionfactory.java

Software Testing Automation Framework (STAF)的开发代码

/*****************************************************************************/
/* Software Testing Automation Framework (STAF)                              */
/* (C) Copyright IBM Corp. 2002, 2004                                        */
/*                                                                           */
/* This software is licensed under the Common Public License (CPL) V1.0.     */
/*****************************************************************************/

package com.ibm.staf.service.stax;
import org.w3c.dom.Node;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
import com.ibm.staf.*;
import java.util.Map;
import java.util.TreeMap;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import com.ibm.staf.service.*;

public class STAXTestcaseActionFactory implements STAXActionFactory,
                                                  STAXListRequestHandler,
                                                  STAXQueryRequestHandler,
                                                  STAXGenericRequestHandler,
                                                  STAXJobManagementHandler
{
    static final String STAX_TESTCASE = new String("Testcase");

    static final String sTestcaseInfoMapClassName = new String(
        "STAF/Service/STAX/TestcaseInfo");
    static final String sQueryTestcaseMapClassName = new String(
        "STAF/Service/STAX/QueryTestcase");

    private static String fDTDInfo =
"\n" +
"<!--================= The Testcase Element ========================= -->\n" +
"<!--\n" +
"     Defines a testcase.  Used in conjunction with the tcstatus\n" +
"     element to mark the status for a testcase.\n" +
"     The name attribute value is evaluated via Python.\n" +
"-->\n" +
"<!ELEMENT testcase   (%task;)>\n" +
"<!ATTLIST testcase\n" +
"          name       CDATA    #REQUIRED\n" +
"          mode       CDATA    \"'default'\"\n" +
">\n";

    public String getDTDInfo()
    {
        return fDTDInfo;
    }

    public String getDTDTaskName()
    {
        return "testcase";
    }

    public STAXTestcaseActionFactory(STAX staxService)
    {
        staxService.registerListHandler("TESTCASES", this);
        staxService.registerQueryHandler("TESTCASE", "Test Name", this);

        staxService.registerJobManagementHandler(this);

        // Set up Testcase Status Update parser

        fUpdateParser.addOption("UPDATE", 1,
                                STAFCommandParser.VALUENOTALLOWED);
        fUpdateParser.addOption("JOB", 1,
                                STAFCommandParser.VALUEREQUIRED);
        fUpdateParser.addOption("TESTCASE", 1,
                                STAFCommandParser.VALUEREQUIRED);
        fUpdateParser.addOption("STATUS", 1,
                                STAFCommandParser.VALUEREQUIRED);
        fUpdateParser.addOption("MESSAGE", 1,
                                STAFCommandParser.VALUEREQUIRED);
        fUpdateParser.addOption("FORCE", 1,
                                STAFCommandParser.VALUENOTALLOWED);

        fUpdateParser.addOptionNeed("UPDATE", "JOB");
        fUpdateParser.addOptionNeed("JOB", "TESTCASE");
        fUpdateParser.addOptionNeed("TESTCASE", "STATUS");
        fUpdateParser.addOptionNeed("STATUS", "TESTCASE");
        fUpdateParser.addOptionNeed("MESSAGE", "STATUS");

        // Set up Testcase Start parser

        fStartParser.addOption("START", 1,
                               STAFCommandParser.VALUENOTALLOWED);
        fStartParser.addOption("JOB", 1,
                               STAFCommandParser.VALUEREQUIRED);
        fStartParser.addOption("TESTCASE", 1,
                               STAFCommandParser.VALUEREQUIRED);
        fStartParser.addOption("KEY", 1,
                               STAFCommandParser.VALUEREQUIRED);

        fStartParser.addOptionNeed("START", "JOB");
        fStartParser.addOptionNeed("JOB", "TESTCASE");
        fStartParser.addOptionNeed("KEY", "TESTCASE");

        // Set up Testcase Stop parser

        fStopParser.addOption("STOP", 1,
                              STAFCommandParser.VALUENOTALLOWED);
        fStopParser.addOption("JOB", 1,
                              STAFCommandParser.VALUEREQUIRED);
        fStopParser.addOption("TESTCASE", 1,
                              STAFCommandParser.VALUEREQUIRED);
        fStopParser.addOption("KEY", 1,
                              STAFCommandParser.VALUEREQUIRED);

        fStopParser.addOptionNeed("STOP", "JOB");
        fStopParser.addOptionNeed("JOB", "TESTCASE");
        fStopParser.addOptionNeed("KEY", "TESTCASE");

        // Construct map-class for testcase list information

        fTestcaseInfoMapClass = new STAFMapClassDefinition(
            sTestcaseInfoMapClassName);

        fTestcaseInfoMapClass.addKey("testcaseName", "Testcase Name");
        fTestcaseInfoMapClass.addKey("numPasses",    "Passes");
        fTestcaseInfoMapClass.addKey("numFails",     "Fails");
        fTestcaseInfoMapClass.addKey("elapsedTime",  "Elapsed Time");
        fTestcaseInfoMapClass.addKey("numStarts",    "Starts");

        // Construct map-class for testcase query information

        fQueryTestcaseMapClass = new STAFMapClassDefinition(
            sQueryTestcaseMapClassName);

        fQueryTestcaseMapClass.addKey("testcaseName", "Testcase Name");
        fQueryTestcaseMapClass.addKey("numPasses",    "Passes");
        fQueryTestcaseMapClass.addKey("numFails",     "Fails");
        fQueryTestcaseMapClass.addKey("lastStatus",   "Last Status");
        fQueryTestcaseMapClass.addKey("lastStatusTimestamp",
                                      "Status Date-Time");
        fQueryTestcaseMapClass.addKey("elapsedTime",  "Elapsed Time");
        fQueryTestcaseMapClass.addKey("numStarts",    "Starts");

        // Register as a GenericRequestHandler
        try
        {
            // Assign STAFServiceInterfaceLevel class that this handler uses

            Class serviceInterfaceClass = Class.forName(STAX.INTERFACE_LEVEL_30);

            int rc = staxService.registerGenericRequestHandler(this,
                                                      serviceInterfaceClass);
            if (rc != 0)
            {
                System.out.println("STAXTestcaseActionFactory." +
                                   "registerGenericRequestHandler() failed");
            }
        }
        catch (ClassNotFoundException e)
        {
            System.out.println("STAXTestcaseActionFactory: " +
                               "registerGenericRequestHandler: " + e);
        }
    }

    public void initJob(STAXJob job)
    {
        if (!job.setData("testcaseMap", new TreeMap()))
        {
            String msg = "STAXTestcaseActionFactory.initJob: setData for " +
                         "testcaseMap failed.";
            job.log(STAXJob.JOB_LOG, "error", msg);
        }

        if (!job.setData("activeTestcaseMap", new HashMap()))
        {
            String msg = "STAXTestcaseActionFactory.initJob: setData for " +
                         "activeTestcaseMap failed.";
            job.log(STAXJob.JOB_LOG, "error", msg);
        }
    }

    public void terminateJob(STAXJob job)
    {
        // Check if any entries are left in the activeTestcaseMap and call
        // the stop testcase method to calculate the elapsed time.

        HashMap activeTestcaseMap = (HashMap)job.getData("activeTestcaseMap");
        TreeMap testcaseMap = (TreeMap)job.getData("testcaseMap");

        synchronized (activeTestcaseMap)
        {
            Iterator it = activeTestcaseMap.values().iterator();

            while (it.hasNext())
            {
                STAXActiveTestcase activeTest = (STAXActiveTestcase)it.next();

                String name = activeTest.getName();
                STAXTimestamp startTime = activeTest.getStartTime();

                // Stop the Testcase

                STAXTestcase theTest = (STAXTestcase)testcaseMap.get(name);

                if (theTest != null)
                {
                    theTest.stop(job, startTime);
                }
                else
                {
                    job.log(STAXJob.JOB_LOG, "warning",
                            "STAXTestcaseActionFactory::terminateJob() - " +
                            "Could not stop testcase: " + name +
                            ".  Not in active testcase map.");
                }
            }
        }

        // Log a summary of the testcase status for the job.

        synchronized (testcaseMap)
        {
            int totalTests = 0;
            int totalPasses = 0;
            int totalFails = 0;
            Iterator it = testcaseMap.keySet().iterator();

            while (it.hasNext())
            {
                String testName = (String)it.next();
                STAXTestcase test = (STAXTestcase)testcaseMap.get(testName);

                int passes = test.getNumPass();
                int fails  = test.getNumFail();

                if (passes == 0 && fails == 0 &&
                    test.getMode() == STAXTestcase.DEFAULT_MODE)
                {
                    // Do not log a status record for the testcase
                }
                else
                {
                    // Log a status record for the testcase

                    String msg = "Testcase: " + testName +
                                 ", Pass: " + passes +
                                 ", Fail: " + fails;

                    if (job.getLogTCElapsedTime())
                    {
                        msg += ", ElapsedTime: " + test.getElapsedTime();
                    }

                    if (job.getLogTCNumStarts())
                    {
                        msg += ", NumStarts: " + test.getNumStarts();
                    }

                    job.log(STAXJob.JOB_LOG, "status", msg);

                    totalTests += 1;
                    totalPasses += passes;
                    totalFails += fails;
                }
            }

            // Log testcase totals
            String msg = "Testcase Totals: Tests: " + totalTests +
                         ", Pass: " + totalPasses + ", Fail: " + totalFails;
            job.log(STAXJob.JOB_LOG, "status", msg);
        }
    }

    public STAFResult handleListRequest(String type, STAXJob job,
                                        STAXRequestSettings settings)
    {
        if (type.equalsIgnoreCase("testcases"))
        {
            // LIST JOB <Job ID> TESTCASES

            // Create the marshalling context and set its map class definitions
            // and create an empty list to contain the block map entries

            STAFMarshallingContext mc = new STAFMarshallingContext();
            mc.setMapClassDefinition(fTestcaseInfoMapClass);
            List tcOutputList = new ArrayList();

            // Iterate though the testcase map, generating the output list

            TreeMap testcaseMap = (TreeMap)job.getData("testcaseMap");

            synchronized (testcaseMap)
            {
                Iterator iter = testcaseMap.values().iterator();

                while (iter.hasNext())
                {
                    STAXTestcase testcase = (STAXTestcase)iter.next();
                    int numPass = testcase.getNumPass();
                    int numFail = testcase.getNumFail();

                    if (testcase.getMode() == STAXTestcase.DEFAULT_MODE &&
                        numPass == 0 && numFail == 0)
                    {
                        // Don't show in list
                    }
                    else
                    {
                        Map tcMap = fTestcaseInfoMapClass.createInstance();