staxfunctionaction.java

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

                String argName = arg.getName();

                if (argType == ARG_REQUIRED)
                {
                    if (!callArgIter.hasNext())
                    {
                        // Raise signal - must provide required argument

                        signalData.fSignalName = "STAXFunctionArgValidate";
                        signalData.fMessageName = "STAXFunctionArgValidateMsg";
                        signalData.fMessage = fCallXMLInfo +
                            "\n\nRequired argument '" + argName +
                            "' not provided in call to function " + fName;
                        return 1;
                    }
                    else
                    {
                        thread.pySetVar(argName, callArgIter.next());
                    }
                } 
                else if (argType == ARG_OPTIONAL)
                {
                    if (!callArgIter.hasNext())
                    {
                        // Evaluate the default value

                        try
                        {
                            thread.pyExec(argName + " = " + 
                                          arg.getDefaultValue());
                        }
                        catch (STAXPythonEvaluationException e)
                        {
                            signalData.fSignalName =
                                "STAXPythonEvaluationError";
                            signalData.fMessageName = "STAXPythonEvalMsg";
                            signalData.fMessage = getXMLInfo() +
                                "\n\nArgument " + argName + " has an " +
                                "invalid default value=" +
                                arg.getDefaultValue();
                            signalData.fPythonException = e;
                            return 2;
                        }
                    }
                    else
                    {
                        thread.pySetVar(argName, callArgIter.next());
                    }
                }
                else if (argType == ARG_OTHER)
                {
                    // Create a PyList of remaining arguments passed by call

                    PyList otherArgList = new PyList();

                    while (callArgIter.hasNext())
                    {
                        otherArgList.append(Py.java2py(callArgIter.next()));
                    }

                    thread.pySetVar(argName, otherArgList);
                }
                else
                {   // Should never happen
                    System.out.println("Invalid function argType=" + argType);
                    return 2;
                }
            } // end for

            // Check if CallArgList has any additional entries

            if (callArgIter.hasNext())
            {
                // Error - more call arguments than function recognizes

                signalData.fSignalName = "STAXFunctionArgValidate";
                signalData.fMessageName = "STAXFunctionArgValidateMsg";
                signalData.fMessage = fCallXMLInfo +
                    "\n\nToo many call arguments: " + callArgList.size() +
                    ".\nFunction only handles " + fArgList.size() +
                    " arguments.";

                try
                {
                    signalData.fMessage += "\nFirst additional argument=" + 
                        callArgIter.next();
                }
                catch (Exception e)
                {
                    // Do nothing as already have enough info in signal message
                    // Need to do in case getting string value of callArgIter.
                    // next() raises a Python exception (as it does if it
                    // contains a STAXGlobal variable.
                }

                return 1;
            }
        }

        else if (fArgDefinition == FUNCTION_DEFINES_MAP_ARGS)
        {
            // Extract a Python dictionary (call arguments) into a Java Map

            Map callArgMap = new HashMap(); 

            if (fCallArgPyObject != null && 
                !(fCallArgPyObject.toString().equals("None")))
            { 
                if (fCallArgPyObject instanceof PyDictionary)
                { 
                    PyList pa = ((PyDictionary)fCallArgPyObject).items();

                    while (pa.__len__() != 0)
                    {
                        PyTuple po = (PyTuple)pa.pop();
                        Object first  = po.__finditem__(0).
                                          __tojava__(Object.class);
                        PyObject second = po.__finditem__(1);
                        callArgMap.put(first, second);
                    }
                }
                else
                {
                    // Raise signal - arguments must be in a map form

                    signalData.fSignalName = "STAXFunctionArgValidate";
                    signalData.fMessageName = "STAXFunctionArgValidateMsg";
                    signalData.fMessage = fCallXMLInfo +
                        "\n\nFunction " + fName + " requires arguments in a " +
                        "map (Python dictionary) form";
                    return 1;
                }
            }

            // Walk function's argument definition list

            for (int i = 0; i < fArgList.size(); i++)
            {
                STAXFunctionArgument arg = 
                    (STAXFunctionArgument)fArgList.get(i);
                int argType = arg.getType();
                String argName = arg.getName();

                if (argType == ARG_REQUIRED)
                {
                    if (callArgMap.containsKey(argName))
                    {
                        thread.pySetVar(argName, callArgMap.get(argName));
                        callArgMap.remove(argName);
                    }
                    else
                    {
                        // Raise signal - must provide required argument

                        signalData.fSignalName = "STAXFunctionArgValidate";
                        signalData.fMessageName = "STAXFunctionArgValidateMsg";
                        signalData.fMessage = fCallXMLInfo +
                            "\n\nRequired argument '" + argName +
                            "' not provided in call to function " + fName;
                        return 1;
                    }
                } 
                else if (argType == ARG_OPTIONAL)
                {
                    if (!callArgMap.containsKey(argName))
                    {
                        // Evaluate the default value

                        try
                        {
                            thread.pyExec(argName + " = " +
                                          arg.getDefaultValue());
                        }
                        catch (STAXPythonEvaluationException e)
                        {
                            signalData.fSignalName =
                                "STAXPythonEvaluationError";
                            signalData.fMessageName = "STAXPythonEvalMsg";
                            signalData.fMessage = getXMLInfo() + "\n\n" +
                                "Argument " + argName + " has an " +
                                "invalid default value=" +
                                arg.getDefaultValue();
                            signalData.fPythonException = e;
                            return 2;
                        }
                    }
                    else
                    {
                        thread.pySetVar(argName, callArgMap.get(argName));
                        callArgMap.remove(argName);
                    }
                }
                else if (argType == ARG_OTHER)
                {
                    // Convert the map of remaining arguments to a PyDictionary

                    Map m = new HashMap();
                    Iterator it = callArgMap.entrySet().iterator();
                    while (it.hasNext())
                    {
                        Map.Entry e = (Map.Entry)it.next();
                        m.put(Py.java2py(e.getKey()),
                              Py.java2py(e.getValue()));
                    }
                    callArgMap = new HashMap(); // Reset to empty
                    
                    // PyDictionary constructor wants a Hashtable
                    thread.pySetVar(argName, 
                                    new PyDictionary(new Hashtable(m)));
                }
                else
                {   // Should never happen
                    System.out.println("Invalid function argType=" + argType);
                    return 2;
                }
            } // end for

            // Check if CallArgMap has any additional entries

            if (!callArgMap.isEmpty())
            {
                // Error - more call arguments than function recognizes

                signalData.fSignalName = "STAXFunctionArgValidate";
                signalData.fMessageName = "STAXFunctionArgValidateMsg";
                signalData.fMessage = fCallXMLInfo +
                    "\n\nToo many call arguments.  Additional arguments: ";
                
                // Iterate thru callArgMap to put extra call argument names
                // into the error message
                
                Iterator it = callArgMap.entrySet().iterator();
                int extraArgNum = 1;

                while (it.hasNext())
                {
                    Map.Entry e = (Map.Entry)it.next();
                    
                    if (extraArgNum != 1)
                        signalData.fMessage += ", ";
                    
                    signalData.fMessage += Py.java2py(e.getKey());
                    extraArgNum++;
                }
                
                return 1;
            }
        }

        else
        {   // This should never happen
            System.out.println("Invalid function argument definition. " +
                               "fArgDefinition=" + fArgDefinition);
        }

        return 0;
    }

    private int fState = INIT;
    private String fName = new String();
    private String fProlog = new String();
    private String fEpilog = new String();
    private String fScope = new String();
    private String fRequires = new String();
    private STAXAction fAction = null;
    private STAXPythonInterpreter fSavePythonInterpreter = null;

    // fArgList contains an list of STAXFunctionArgument objects
    private int       fArgDefinition = FUNCTION_DEFINES_NO_ARGS;
    private ArrayList fArgList = new ArrayList();

    // Contains the arguments passed by the call to the function
    private PyObject  fCallArgPyObject;

    private String    fCallXMLInfo;

    private String    fParentFunctionName = new String();

    private class STAXSignalData
    {
        private STAXSignalData() {}
        
        private String fSignalName = "";
        private String fMessageName = "";
        private String fMessage = "";
        private STAXPythonEvaluationException fPythonException = null;
    }
}