fsext.java

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

        // If all checks are successful break out of big loop and return OK.
        // Otherwise, delay and start check again at top of loop.

        if (success)
            break;
        else
            sHandle.submit2("local", "DELAY", "DELAY " + poll);
        
    } // end big for loop

    return new STAFResult(STAFResult.Ok);
}

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

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

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

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

    // Parse request String

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

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

    // Get FILE and STRING options

    File file;
    Enumeration strings;

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

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

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

    // Get all instances of STRING, store in a Vector and get the Enumeration

    int numStrings = pResult.optionTimes(STRING);
    Vector stringVect = new Vector();

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

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

        String tempString = res.result;
        stringVect.add(tempString);
    }

    strings = stringVect.elements();

    // Check if NOT option specified

    boolean fileContainsString = true;

    if (pResult.optionTimes(NOT) == 1)
        fileContainsString = false;
    
    // Check if IGNORECASE option specified

    boolean ignoreCase = false;

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

    boolean saveOnFail = false;

    if (pResult.optionTimes(SAVEONFAILURE) == 1)
        saveOnFail = true;
    
    // Read entire file and store as a String

    FileReader in = null;
    String data = null;

    try
    {
        in = new FileReader(file);
        int numBytes = (int) file.length();
        char[] fileData = new char[numBytes];
        in.read(fileData);
        data = new String(fileData);

        if (ignoreCase) data = data.toLowerCase();
    }
    catch(IOException ioe)
    {
        return new STAFResult(IOERROR, ioe.toString());
    }
    finally
    {
        try
        {
            in.close();
        }
        catch(Throwable t) {} //don't care
    }

    // Scan entire file for presence or absence of the specified Strings

    if (fileContainsString)
    {
        // Check that file contains list of Strings

        while(strings.hasMoreElements())
        {
            String tempS = (String) strings.nextElement();

            if (ignoreCase)
            {
                // IGNORECASE specified
                tempS = tempS.toLowerCase();
            }

            if (data.indexOf(tempS) == -1)
            {
                // String not found

                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 new STAFResult(STRINGNOTFOUND, tempS);
            }
        }
    }
    else
    {
        // Check that the file does NOT contain the list of Strings

        while (strings.hasMoreElements())
        {
            String tempS = (String)strings.nextElement();

            if (ignoreCase) tempS = tempS.toLowerCase();
            
            int index = data.indexOf(tempS);

            if (index != -1)
            {
                // String was found in the file

                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());
                    }
                }

                Map resultMap = fFileContainsErrorMapClass.createInstance();
                resultMap.put("offset", String.valueOf(index));
                resultMap.put("string", tempS);

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

                return new STAFResult(STRINGFOUND, mc.marshall());
            }
        }
    }

    return new STAFResult(STAFResult.Ok);
}

/*****************************************************************************/
/*                                                                           */
/* Method: help                                                              */
/* Description: returns service help information                             */
/* Parameters: none                                                          */
/* Returns: STAFResult.OK                                                    */
/*                                                                           */
/*****************************************************************************/

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

    STAFResult trustResult = STAFUtil.validateTrust(
        1, fServiceName, "HELP", fLocalMachineName, info);

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

    // Return help text for the service

    String help =
        fServiceName + " Service Help\n\n"+
        "COMPAREDIR DIR <Directory> FILE <File> [FILE <File>]... " +
        "[EXISTS]\n"+
        "     [ATTEMPTS <Num Attempts> [INTERVAL <Polling Interval>]]\n\n"+
        "FILECONTAINS FILE <File> STRING <String> [STRING <String>]... " +
        "[NOT]\n"+
        "     [IGNORECASE] [SAVEONFAILURE]\n\n"+
        "LINECONTAINS FILE <File> STRING <String> [STRING <String>]... " +
        "[IGNORECASE]\n"+
        "     [SAVEONFAILURE] [LINENUMBER <Line #>]\n\n"+
        "PROCESSFILE [MODE <capture | compare>] FILE1 <File1> FILE2 <File2> " +
        "[SORT]\n"+
        "     [SAVEONFAILURE]\n\n"+
        "SUBSTITUTE FILE <File> [TOFILE <File>] [TOMACHINE <Machine>]\n"+
        "     [FAILIFNEW | FAILIFEXISTS]\n\n"+
        "WAITFORFILE FILE <File> [TIMEOUT <Max Wait Time>]\n"+
        "     [INTERVAL <Polling Interval>] [NOT]\n\n"+
        "VERSION\n\n"+
        "HELP";

    return new STAFResult(STAFResult.Ok, help);
}

/*****************************************************************************/
/*                                                                           */
/* Method: init                                                              */
/* Description: required by interface STAFServiceInterfaceLevel30            */
/*              creates parsers and registers with STAF                      */
/*                                                                           */
/*****************************************************************************/

public STAFResult init(STAFServiceInterfaceLevel30.InitInfo initInfo)
{
    /* Generate STAF Parsers */

    /* Generate PROCESSFILE parser */

    procFileParser = new STAFCommandParser();

    procFileParser.addOption(PROCESSFILE, 1,
        STAFCommandParser.VALUENOTALLOWED);
    procFileParser.addOption(MODE, 1, STAFCommandParser.VALUEREQUIRED);
    procFileParser.addOption(FILE1, 1, STAFCommandParser.VALUEREQUIRED);
    procFileParser.addOption(FILE2, 1, STAFCommandParser.VALUEREQUIRED);
    procFileParser.addOption(SORT, 1, STAFCommandParser.VALUENOTALLOWED);
    procFileParser.addOption(SAVEONFAILURE, 1,
        STAFCommandParser.VALUENOTALLOWED);

    procFileParser.addOptionGroup(FILE1, 1, 1);
    procFileParser.addOptionGroup(FILE2, 1, 1);

    /* Generete COMPAREDIR parser */

    compDirParser = new STAFCommandParser();
    compDirParser.addOption(COMPAREDIR, 1, STAFCommandParser.VALUENOTALLOWED);
    compDirParser.addOption(DIR, 1, STAFCommandParser.VALUEREQUIRED);
    compDirParser.addOption(FILE, 0, STAFCommandParser.VALUEREQUIRED);
    compDirParser.addOption(EXISTS, 1, STAFCommandParser.VALUENOTALLOWED);
    compDirParser.addOption(ATTEMPTS, 1, STAFCommandParser.VALUEREQUIRED);
    compDirParser.addOption(POLL, 1, STAFCommandParser.VALUEREQUIRED);

    compDirParser.addOptionGroup(DIR, 1, 1);
    compDirParser.addOptionGroup(FILE, 1, 1);

    compDirParser.addOptionNeed(POLL, ATTEMPTS);

    /* Generate FILECONTAINS parser */

    fileContainsParser = new STAFCommandParser();

    fileContainsParser.addOption(FILECONTAINS, 1,
        STAFCommandParser.VALUENOTALLOWED);
    fileContainsParser.addOption(FILE, 1, STAFCommandParser.VALUEREQUIRED);
    fileContainsParser.addOption(STRING, 0, STAFCommandParser.VALUEREQUIRED);
    fileContainsParser.addOption(NOT, 1, STAFCommandParser.VALUENOTALLOWED);
    fileContainsParser.addOption(IGNORECASE, 1,
        STAFCommandParser.VALUENOTALLOWED);
    fileContainsParser.addOption(SAVEONFAILURE, 1,
        STAFCommandParser.VALUENOTALLOWED);

    fileContainsParser.addOptionGroup(FILE, 1, 1);
    fileContainsParser.addOptionGroup(STRING, 1, 1);

    /* Generate LINECONTAINS parser */

    lineContainsParser = new STAFCommandParser();

    lineContainsParser.addOption(LINECONTAINS, 1,
        STAFCommandParser.VALUENOTALLOWED);
    lineContainsParser.addOption(FILE, 1, STAFCommandParser.VALUEREQUIRED);
    lineContainsParser.addOption(STRING, 0, STAFCommandParser.VALUEREQUIRED);
    lineContainsParser.addOption(IGNORECASE, 1,
        STAFCommandParser.VALUENOTALLOWED);
    lineContainsParser.addOption(SAVEONFAILURE, 1,
        STAFCommandParser.VALUENOTALLOWED);
    lineContainsParser.addOption(LINENUMBER, 1,
        STAFCommandParser.VALUEREQUIRED);

    lineContainsParser.addOptionGroup(FILE, 1, 1);
    lineContainsParser.addOptionGroup(STRING, 1, 1);

    /* Generate WAITFORFILE parser */

    waitForFileParser = new STAFCommandParser();

    waitForFileParser.addOption(WAITFORFILE, 1,
        STAFCommandParser.VALUENOTALLOWED);
    waitForFileParser.addOption(FILE, 1, STAFCommandParser.VALUEREQUIRED);
    waitForFileParser.addOption(TIMEOUT, 1, STAFCommandParser.VALUEREQUIRED);
    waitForFileParser.addOption(POLL, 1, STAFCommandParser.VALUEREQUIRED);
    waitForFileParser.addOption(NOT, 1, STAFCommandParser.VALUENOTALLOWED);

    waitForFileParser.addOptionGroup(FILE, 1, 1);

    /* Generate SUBSTITUTE parser */

    substituteParser = new STAFCommandParser();

    substituteParser.addOption(SUBSTITUTE, 1,
                               STAFCommandParser.VALUENOTALLOWED);
    substituteParser.addOption(FILE, 1, STAFCommandParser.VALUEREQUIRED);
    substituteParser.addOption(TOFILE, 1, STAFCommandParser.VALUEREQUIRED);
    substituteParser.addOption(TOMACHINE, 1, STAFCommandParser.VALUEREQUIRED);
    substituteParser.addOption(FAILIFEXISTS, 1,
                               STAFCommandParser.VALUENOTALLOWED);
    substituteParser.addOption(FAILIFNEW, 1,
                               STAFCommandParser.VALUENOTALLOWED);

    substituteParser.addOptionGroup(FILE, 1, 1);
    substituteParser.addOptionGroup(FAILIFEXISTS + " " + FAILIFNEW, 0, 1);

    // Construct map class for the result from an unsuccessful FILECONTAINS NOT
    // request

    fFileContainsErrorMapClass = new STAFMapClassDefinition(
        "STAF/Service/FSExt/FileContainsNotError");
    fFileContainsErrorMapClass.addKey("offset", "Byte Offset");
    fFileContainsErrorMapClass.addKey("string", "Found String");
    
    // Construct map class for the result from a LINECONTAINS request

    fLineContainsMapClass = new STAFMapClassDefinition(
        "STAF/Service/FSExt/LineContainsResult");
    fLineContainsMapClass.addKey("lineNumber", "Line Number");
    fLineContainsMapClass.addKey("line", "Line");

    /* Set name */

    fServiceName = initInfo.name;

    /* Create STAFHandle */

    try
    {
        sHandle = new STAFHandle(initInfo.name);
    }