fsext.java

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

    catch(STAFException se)
    {
        se.printStackTrace();
        return new STAFResult(STAFResult.STAFRegistrationError,
                              se.toString());
    }

    // Resolve the machine name variable for the local machine

    STAFResult res = STAFUtil.resolveInitVar("{STAF/Config/Machine}", sHandle);

    if (res.rc != STAFResult.Ok) return res;

    fLocalMachineName = res.result;

    /* Register RCs with the HELP service */

    int rc = this.registerHelp(initInfo.name);

    if (rc != STAFResult.Ok)
        return new STAFResult(
            rc, "Error registering RCs with the HELP service.");

    /* Finished */

    return new STAFResult(rc);

}

/*****************************************************************************/
/*                                                                           */
/* Method: lineContains                                                      */
/* Description: performs lineContains service function                       */
/* Parameters: info - RequestInfo passed to acceptRequest                    */
/* Returns: STAFResult                                                       */
/*                                                                           */
/*****************************************************************************/

private STAFResult lineContains(STAFServiceInterfaceLevel30.RequestInfo info)
{
    // Verify the requester has at least trust level 3

    STAFResult trustResult = STAFUtil.validateTrust(
        3, fServiceName, "LINECONTAINS", fLocalMachineName, info);

    if (trustResult.rc != STAFResult.Ok) return trustResult;

    // Parse request string

    STAFCommandParseResult pResult = lineContainsParser.parse(info.request);

    if (pResult.rc != 0)
    {
        return new STAFResult(STAFResult.InvalidRequestString,
                              pResult.errorBuffer);
    }

    // Get FILE and STRING options

    STAFResult res = STAFUtil.resolveRequestVar(
        pResult.optionValue(FILE), sHandle, info.requestNumber);

    if (res.rc != 0) return res;

    String filename = res.result;
    File file = new File(filename);

    // Get all instances of STRING and store in a Vector

    Vector stringList = new Vector();

    for (int i = 1; i <= pResult.optionTimes(STRING); i++)
    {
        res = STAFUtil.resolveRequestVar(
            pResult.optionValue(STRING, i), sHandle, info.requestNumber);

        if (res.rc != 0) return res;
           
        String tempString = res.result;
        stringList.add(tempString);
    }

    // Check if IGNORECASE option is specified

    boolean ignoreCase = false;

    if (pResult.optionTimes(IGNORECASE) == 1)
        ignoreCase = true;
    
    // Check if SAVEONFAILURE option is specified

    boolean saveOnFail = false;

    if (pResult.optionTimes(SAVEONFAILURE) == 1)
        saveOnFail = true;
    
    // Parse LINENUMBER option

    boolean strictLine = false;
    int specificLineNumber = 0;

    if (pResult.optionTimes(LINENUMBER) == 1)
    {
        strictLine = true;
            
        res = STAFUtil.resolveRequestVarAndCheckInt(
            LINENUMBER, pResult.optionValue(LINENUMBER),
            sHandle, info.requestNumber);

        if (res.rc != 0) return res;

        specificLineNumber = Integer.parseInt(res.result);

        if (specificLineNumber == 0)
        {
            return new STAFResult(
                STAFResult.InvalidRequestString, "LINENUMBER cannot be 0.");
        }
    }

    // Read file one line at a time and search each line for string list.

    BufferedReader in = null;
    int numStrings = stringList.size();
    int lineNumber = 0;
    Vector lineStore = new Vector();

    try
    {
        in = new BufferedReader(new FileReader(file));

        while(true)
        {
            lineNumber++;

            // Read next line from file
            String line = in.readLine();

            if (line == null)
            {
                // Reached end of file
                break;
            }

            if (ignoreCase)
            {
                line = line.toLowerCase();
            }

            if (strictLine)
            {
                // Simply store line for later comparison
                lineStore.add(line);
                continue;
            }

            boolean searchResult = ServiceUtilities.lineContainsStrings(
                line, stringList, ignoreCase);

            if (searchResult)
            {
                // Found all strings in a single line

                Map resultMap = fLineContainsMapClass.createInstance();
                resultMap.put("lineNumber", String.valueOf(lineNumber));
                resultMap.put("line", line);

                STAFMarshallingContext mc = new STAFMarshallingContext();
                mc.setRootObject(resultMap);
                mc.setMapClassDefinition(fLineContainsMapClass);

                return new STAFResult(STAFResult.Ok, mc.marshall());
            }
        }
    }
    catch(IOException ioe)
    {
        return new STAFResult(IOERROR, ioe.toString());
    }
    finally
    {
        try
        {
            in.close();
        }
        catch(Throwable t) {} // Don't care
    }

    STAFResult result = new STAFResult(STRINGNOTFOUND); // Default from here

    if (strictLine)
    {
        // Now do comparison

        int totalLines = lineStore.size();

        if (Math.abs(specificLineNumber) > totalLines)
        {
            // Line not in file
            result = new STAFResult(LINEDOESNOTEXIST, 
                                    String.valueOf(totalLines));
        }

        STAFMarshallingContext mc = new STAFMarshallingContext();
        mc.setMapClassDefinition(fLineContainsMapClass);

        Map resultMap = fLineContainsMapClass.createInstance();

        if (specificLineNumber > 0)
        {
            String line = (String)lineStore.get(specificLineNumber - 1);

            resultMap.put("lineNumber",
                          String.valueOf(specificLineNumber));
            resultMap.put("line", line);
            mc.setRootObject(resultMap);

            if (ServiceUtilities.lineContainsStrings(
                line, stringList, ignoreCase))
            {
                return new STAFResult(STAFResult.Ok, mc.marshall());
            }
            else
            {
                result = new STAFResult(STRINGNOTFOUND, mc.marshall());
            }
        }
        else
        {
            int lineNum = totalLines + specificLineNumber;
            String line = (String)lineStore.get(lineNum);

            resultMap.put("lineNumber", String.valueOf(lineNum + 1));
            resultMap.put("line", line);
            mc.setRootObject(resultMap);

            if (ServiceUtilities.lineContainsStrings(
                line, stringList, ignoreCase))
            {
                return new STAFResult(STAFResult.Ok, mc.marshall());
            }
            else
            {
                result = new STAFResult(STRINGNOTFOUND, mc.marshall());
            }
        }
    }

    // If we get here query failed

    if (saveOnFail)
    {
        // Capture the file for later comparison

        ExtFile capture = new ExtFile(file);

        try
        {
            capture.captureFile(file.getPath() + ".fail");
        }
        catch(IOException ioe)
        {
            return new STAFResult(IOERROR, ioe.toString());
        }
    }

    return result;

}

/*****************************************************************************/
/*                                                                           */
/* Method: processFile                                                       */
/* Description: performs processFile service function                        */
/* Parameters: info - RequestInfo passed to acceptRequest                    */
/* Returns: STAFResult                                                       */
/*                                                                           */
/*****************************************************************************/

private STAFResult processFile(STAFServiceInterfaceLevel30.RequestInfo info)
{
    // Verify the requester has at least trust level 3

    STAFResult trustResult = STAFUtil.validateTrust(
        3, fServiceName, "PROCESSFILE", fLocalMachineName, info);

    if (trustResult.rc != STAFResult.Ok) return trustResult;

    /* Parse request string */

    STAFCommandParseResult pResult = procFileParser.parse(info.request);

    if (pResult.rc != 0)
    {
        return new STAFResult(STAFResult.InvalidRequestString,
                              pResult.errorBuffer);
    }

    /* Get parameters */

    boolean compare = true; //if true compare, if false capture
    boolean sort = false;
    String mode, file1, file2;

    /* Get FILE names */

    STAFResult res = STAFUtil.resolveRequestVar(
        pResult.optionValue(FILE1), sHandle, info.requestNumber);

    if (res.rc != 0) return res;

    file1 = res.result;

    res = STAFUtil.resolveRequestVar(
        pResult.optionValue(FILE2), sHandle, info.requestNumber);

    if (res.rc != 0) return res;

    file2 = res.result;

    /* Get MODE */

    if (pResult.optionTimes(MODE) == 1)
    {
        res = STAFUtil.resolveRequestVar(
            pResult.optionValue(MODE), sHandle, info.requestNumber);

        if (res.rc != 0) return res;

        mode = res.result;

        if (mode.equalsIgnoreCase(CAPTURE))
        {
            compare = false;
        }
        else if (mode.equalsIgnoreCase(COMPARE))
        {
            compare = true;
        }
        else
        {
            return new STAFResult(STAFResult.InvalidRequestString,
                "Invalid value specified for MODE");
        }
    }

    /* Get SORT */

    if (pResult.optionTimes(SORT) == 1)
    {
        sort = true;
    }

    /* Parse SAVEONFAILURE parameter */

    boolean saveOnFail = false;

    if (pResult.optionTimes(SAVEONFAILURE) == 1)
    {
        saveOnFail = true;
    }

    /* Perform capture or compare */

    ExtFile sourceFile = new ExtFile(file1);
    sourceFile.setSaveFailures(saveOnFail);

    try
    {
        if (compare)
        {
            if (!sourceFile.compareFile(file2, sort))
            {
                return new STAFResult(COMPAREFAIL);
            }
        }
        else
        {
            sourceFile.captureFile(file2);
        }
    }
    catch(IOException ioe)
    {
        return new STAFResult(IOERROR, ioe.toString());
    }

    return new STAFResult(STAFResult.Ok);