stafconfig.cpp

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

            return 1;
        }

        if (!maxFiles.isDigits())
        {
            cout << "Error on MAXFILES setting, " << line << endl
                 << "MAXFILES must be a non-negative integer" << endl;
            return 1;
        }

        gMaxFiles = (long)maxFiles.asUInt();
    }

    if (parsedResult->optionTimes("MAXQUEUESIZE") != 0)
    {
        // Handle MAXQUEUESIZE

        STAFString maxQueueSize;

        rc = RESOLVE_STRING_OPTION("MAXQUEUESIZE", maxQueueSize);

        if (rc != kSTAFOk)
        {
            cout << "Error on MAXQUEUESIZE setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("MAXQUEUESIZE") << ", RC: "
                 << rc << endl;
            return 1;
        }

        if (!maxQueueSize.isDigits())
        {
            cout << "Error on MAXQUEUESIZE setting, " << line << endl
                 << "MAXQUEUESIZE must be a non-negative integer" << endl;
            return 1;
        }

        gMaxQueueSize = maxQueueSize.asUInt();
    }

    if (parsedResult->optionTimes("INITIALTHREADS") != 0)
    {
        // Handle INITIALTHREADS

        STAFString initialThreads;

        rc = RESOLVE_STRING_OPTION("INITIALTHREADS", initialThreads);

        if (rc != kSTAFOk)
        {
            cout << "Error on INITIALTHREADS setting, " << line  << endl
                 << "Error resolving "
                 << parsedResult->optionValue("INITIALTHREADS") << ", RC: "
                 << rc << endl;
            return 1;
        }

        if (!initialThreads.isDigits() ||
            (initialThreads.asUInt() < 1))
        {
            cout << "Error on INITIALTHREADS setting, " << line << endl
                 << "INITIALTHREADS must be a positive integer" << endl;
            return 1;
        }

        gNumInitialThreads = initialThreads.asUInt();
    }

    if (parsedResult->optionTimes("THREADGROWTHDELTA") != 0)
    {
        // Handle THREADGROWTHDELTA

        STAFString threadDelta;

        rc = RESOLVE_STRING_OPTION("THREADGROWTHDELTA", threadDelta);

        if (rc != kSTAFOk)
        {
            cout << "Error on THREADGROWTHDELTA setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("THREADGROWTHDELTA") << ", RC: "
                 << rc << endl;
            return 1;
        }

        if (!threadDelta.isDigits() || (threadDelta.asUInt() < 1))
        {
            cout << "Error on THREADGROWTHDELTA setting, " << line << endl
                 << "THREADGROWTHDELTA must be a positive integer" << endl;
            return 1;
        }

        gThreadManagerPtr->setGrowthDelta(threadDelta.asUInt());
    }

    if (parsedResult->optionTimes("DEFAULTINTERFACE") != 0)
    {
        STAFString defaultInterface;

        rc = RESOLVE_STRING_OPTION("DEFAULTINTERFACE", defaultInterface);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTINTERFACE setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTINTERFACE") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = gConnectionManagerPtr->setDefaultConnectionProvider(
            defaultInterface);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTINTERFACE setting, " << line << endl
                 << "Interface " << defaultInterface
                 << " is not registered, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTAUTHENTICATOR") != 0)
    {
        STAFString defaultAuth;

        rc = RESOLVE_STRING_OPTION("DEFAULTAUTHENTICATOR", defaultAuth);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHENTICATOR setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTAUTHENTICATOR") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = gServiceManagerPtr->setDefaultAuthenticator(defaultAuth);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHENTICATOR setting, " << line << endl
                 << "Authenticator " << defaultAuth << " is not registered, RC: "
                 << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTSTOPUSING") != 0)
    {
        STAFString stopString;
        STAFProcessStopMethod_t stopMethod;

        rc = RESOLVE_STRING_OPTION("DEFAULTSTOPUSING", stopString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSTOPUSING setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTSTOPUSING") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::getStopMethodFromString(stopMethod,
                                                         stopString);
        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSTOPUSING setting, " << line << endl
                 << "Invalid value, " << stopString << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultStopMethod(stopMethod);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSTOPUSING setting, " << line << endl
                 << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTFOCUS") != 0)
    {
        STAFString focusString;
        STAFProcessConsoleFocus_t focus;

        rc = RESOLVE_STRING_OPTION("DEFAULTFOCUS", focusString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTFOCUS setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTFOCUS") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::getConsoleFocusFromString(focus, focusString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTFOCUS setting, " << line << endl
                 << "RC: " << rc << ", Invalid value: " << focusString << endl
                 << "Must be Background, Foreground, or Minimized." << endl;
            return 1;
        }

        STAFProcessService::setDefaultConsoleFocus(focus);
    }

    if (parsedResult->optionTimes("PROCESSAUTHMODE") != 0)
    {
        STAFString authModeString;
        STAFProcessAuthenticationMode_t authMode;

        rc = RESOLVE_STRING_OPTION("PROCESSAUTHMODE", authModeString);

        if (rc != kSTAFOk)
        {
            cout << "Error on PROCESSAUTHMODE setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("PROCESSAUTHMODE") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::getAuthModeFromString(authMode,
                                                       authModeString);

        if (rc != kSTAFOk)
        {
            cout << "Error on PROCESSAUTHMODE setting, " << line << endl
                 << "Invalid value, " << authModeString << ", RC: "
                 << rc << endl;
            return 1;
        }

        unsigned int osRC = 0;

        rc = STAFProcessService::setAuthMode(authMode, osRC);

        if (rc != kSTAFOk)
        {
            cout << "Error on PROCESSAUTHMODE setting, " << line << endl
                 << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTAUTHUSERNAME") != 0)
    {
        STAFString authUsernameString;

        rc = RESOLVE_STRING_OPTION("DEFAULTAUTHUSERNAME", authUsernameString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHUSERNAME setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTAUTHUSERNAME") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultAuthUsername(authUsernameString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHUSERNAME setting, " << line << endl
                 << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTAUTHPASSWORD") != 0)
    {
        STAFString authPasswordString;

        rc = RESOLVE_STRING_OPTION("DEFAULTAUTHPASSWORD", authPasswordString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHPASSWORD setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTAUTHPASSWORD") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultAuthPassword(authPasswordString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHPASSWORD setting, " << line << endl
                 << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTAUTHDISABLEDACTION") != 0)
    {
        STAFString defaultAuthDisabledActionString;
        STAFProcessDisabledAuthAction_t defaultAuthDisabledAction;

        rc = RESOLVE_STRING_OPTION("DEFAULTAUTHDISABLEDACTION",
                                   defaultAuthDisabledActionString);
        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHDISABLEDACTION setting, " << line
                 << endl << "Error resolving "
                 << parsedResult->optionValue("DEFAULTAUTHDISABLEDACTION")
                 << ", RC: " << rc << endl;
            return 1;
        }

        rc = STAFProcessService::getDefaultDisabledAuthActionFromString(
             defaultAuthDisabledAction, defaultAuthDisabledActionString);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHDISABLEDACTION setting, " << line
                 << endl
                 << "Invalid value, " << defaultAuthDisabledActionString
                 << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultDisabledAuthAction(
             defaultAuthDisabledAction);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTAUTHDISABLEDACTION setting, " << line
                 << endl
                 << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTNEWCONSOLE") != 0)
        gDefaultConsoleMode = kSTAFProcessNewConsole;
    else if (parsedResult->optionTimes("DEFAULTSAMECONSOLE") != 0)
        gDefaultConsoleMode = kSTAFProcessSameConsole;

    if (parsedResult->optionTimes("DEFAULTSHELL") != 0)
    {
        STAFString shellCommand;

        rc = RESOLVE_STRING_OPTION("DEFAULTSHELL", shellCommand);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSHELL setting, " << line << endl
                 << "Error resolving "
                 << parsedResult->optionValue("DEFAULTSHELL") << ", RC: "
                 << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultShellCommand(shellCommand);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSHELL setting, " << line << endl
                 << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTSAMECONSOLESHELL") != 0)
    {
        STAFString shellCommand;

        rc = RESOLVE_STRING_OPTION("DEFAULTSAMECONSOLESHELL", shellCommand);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSAMECONSOLESHELL setting, " << line
                 << endl << "Error resolving "
                 << parsedResult->optionValue("DEFAULTSAMECONSOLESHELL")
                 << ", RC: " << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultSameConsoleShell(shellCommand);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTSAMECONSOLESHELL setting, " << line
                 << endl << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("DEFAULTNEWCONSOLESHELL") != 0)
    {
        STAFString shellCommand;

        rc = RESOLVE_STRING_OPTION("DEFAULTNEWCONSOLESHELL", shellCommand);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTNEWCONSOLESHELL setting, " << line
                 << endl << "Error resolving "
                 << parsedResult->optionValue("DEFAULTNEWCONSOLESHELL")
                 << ", RC: " << rc << endl;
            return 1;
        }

        rc = STAFProcessService::setDefaultNewConsoleShell(shellCommand);

        if (rc != kSTAFOk)
        {
            cout << "Error on DEFAULTNEWCONSOLESHELL setting, " << line
                 << endl << "Error changing the default, RC: " << rc << endl;
            return 1;
        }
    }

    // Handle ENABLEDIAGS

    if (parsedResult->optionTimes("ENABLEDIAGS") != 0)
    {
        rc = gDiagManagerPtr->enable();

        if (rc != kSTAFOk)
        {
            cout << "Error on ENABLEDIAGS setting, " << line
                 << endl << "RC: " << rc << endl;
            return 1;
        }
    }

    // Handle STRICTFSCOPYTRUST

    if (parsedResult->optionTimes("STRICTFSCOPYTRUST") != 0)
    {
        gStrictFSCopyTrust = 1;
    }
    
    // Handle RESULTCOMPATIBILITYMODE

    if (parsedResult->optionTimes("RESULTCOMPATIBILITYMODE") != 0)
    {
        STAFString mode;

        rc = RESOLVE_STRING_OPTION("RESULTCOMPATIBILITYMODE", mode);

        if (rc != kSTAFOk)
        {
            cout << "Error on RESULTCOMPATIBILITYMODE setting, " << line
                 << endl << "Error resolving "
                 << parsedResult->optionValue("RESULTCOMPATIBILITYMODE")
                 << ", RC: " << rc << endl;
            return 1;
        }

        if (mode.isEqualTo("NONE", kSTAFStringCaseInsensitive))
        {
            gResultCompatibilityMode = kSTAFResultCompatibilityNone;
        }
        else if (mode.isEqualTo("VERBOSE", kSTAFStringCaseInsensitive))
        {
            gResultCompatibilityMode = kSTAFResultCompatibilityVerbose;
        }
        else
        {
            cout << "Error on RESULTCOMPATIBILITYMODE setting, " << line
                 << endl << "Invalid value.  Must be None or Verbose,  RC: "
                 << kSTAFInvalidValue << endl;

            return 1;
        }
    }

    return 0;
}