@Override
public Set<VariableRef> getReadsFrom() {
Set<VariableRef> s = new HashSet<VariableRef>();
for (Argument a : args) {
if (a.getValue() instanceof VariableRef) {
s.add((VariableRef) a.getValue());
}
}
return s;
}
@Override
public void parseArgs(ScriptEntry scriptEntry) throws InvalidArgumentsException {
// Parse Arguments
for (Argument arg : aH.interpret(scriptEntry.getArguments())) {
if (!scriptEntry.hasObject("action") && arg.matchesEnum(Action.values()))
scriptEntry.addObject("action", Action.valueOf(arg.getValue().toUpperCase()));
else if (!scriptEntry.hasObject("range")
&& arg.matchesPrimitive(aH.PrimitiveType.Double)
&& arg.matchesPrefix("range, r")) scriptEntry.addObject("range", arg.asElement());
else if (!scriptEntry.hasObject("id") && arg.matchesPrefix("id, i"))
scriptEntry.addObject("id", arg.asElement());
else if (!scriptEntry.hasObject("location") && arg.matchesArgumentType(dLocation.class))
scriptEntry.addObject("location", arg.asType(dLocation.class));
else arg.reportUnhandled();
}
// Check required arguments
if (!scriptEntry.hasNPC())
throw new InvalidArgumentsException("NPC linked was missing or invalid.");
if (!scriptEntry.hasObject("action"))
throw new InvalidArgumentsException(
"Must specify an 'Anchor Action'. Valid: " + Action.values());
}
@Override
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("[UnitGroup ");
buf.append(id);
buf.append(" :type ");
buf.append(type);
buf.append(" :ownerId ");
buf.append(ownerId);
buf.append(" (:required");
for (Argument arg : unitTypeReqs) {
buf.append(" ");
buf.append(arg.getName());
buf.append(" ");
buf.append(arg.getValue());
}
buf.append(") (:actual");
if (!isEmpty()) {
for (Map.Entry<String, Integer> entry : getRepresentative().getUnitTypes().entrySet()) {
buf.append(" ");
buf.append(entry.getKey());
buf.append(" ");
buf.append(entry.getValue());
}
}
buf.append(")]");
return buf.toString();
}
/*
verifies that each of our registered parameters has a value, either given or default
throws an exeption otherwise
*/
private void verify() throws Exception {
for (Argument parameter : parameters.values()) {
if (parameter.getValue() == null && parameter.getDefaultValue() == null) {
throw new Exception(
String.format("Argument '%s' is required. Please see usage.", parameter.name));
}
}
}
/** @deprecated */
public void set(ArgumentList inArgList) {
int nInArgs = inArgList.size();
for (int n = 0; n < nInArgs; n++) {
Argument inArg = inArgList.getArgument(n);
String inArgName = inArg.getName();
Argument arg = getArgument(inArgName);
if (arg == null) continue;
arg.setValue(inArg.getValue());
}
}
/**
* Goes through SynapsePath argument list, evaluating each by calling stringValueOf and returns a
* HashMap String, String array where each item will contain a hash map with key "evaluated
* expression" and value "SynapsePath type".
*
* @param synCtx
* @return
*/
private HashMap<String, String>[] getArgValues(MessageContext synCtx) {
HashMap<String, String>[] argValues = new HashMap[pathArgumentList.size()];
HashMap<String, String> valueMap;
String value = "";
for (int i = 0; i < pathArgumentList.size(); ++i) {
/*ToDo use foreach*/
Argument arg = pathArgumentList.get(i);
if (arg.getValue() != null) {
value = arg.getValue();
if (!isWellFormedXML(value)) {
value = StringEscapeUtils.escapeXml(value);
}
value = Matcher.quoteReplacement(value);
} else if (arg.getExpression() != null) {
value = arg.getExpression().stringValueOf(synCtx);
if (value != null) {
// XML escape the result of an expression that produces a literal, if the target format
// of the payload is XML.
if (!isWellFormedXML(value)
&& !arg.getExpression().getPathType().equals(SynapsePath.JSON_PATH)
&& XML_TYPE.equals(getType())) {
value = StringEscapeUtils.escapeXml(value);
}
value = Matcher.quoteReplacement(value);
} else {
value = "";
}
} else {
handleException("Unexpected arg type detected", synCtx);
}
// value = value.replace(String.valueOf((char) 160), " ").trim();
valueMap = new HashMap<String, String>();
if (null != arg.getExpression()) {
valueMap.put(value, arg.getExpression().getPathType());
} else {
valueMap.put(value, SynapsePath.X_PATH);
}
argValues[i] = valueMap;
}
return argValues;
}
public void print() {
Debug.message("Action : " + getName());
ArgumentList argList = getArgumentList();
int nArgs = argList.size();
for (int n = 0; n < nArgs; n++) {
Argument arg = argList.getArgument(n);
String name = arg.getName();
String value = arg.getValue();
String dir = arg.getDirection();
Debug.message(" [" + n + "] = " + dir + ", " + name + ", " + value);
}
}
/**
* Set all the Argument which are Output Argoument to the given value in the argument list
*
* @param outArgList
*/
public void setResArgs(ArgumentList outArgList) {
int nArgs = size();
for (int n = 0; n < nArgs; n++) {
Argument arg = getArgument(n);
if (arg.isOutDirection()) {
String argName = arg.getName();
Argument outArg = outArgList.getArgument(argName);
if (outArg == null)
throw new IllegalArgumentException("Argument \"" + argName + "\" missing.");
arg.setValue(outArg.getValue());
}
}
}
private URI getURI(FormattedMessage message) {
for (Argument arg : message.getArgs()) {
if (arg.getType().equals(ArgumentType.URL)) {
try {
return new URI(arg.getValue());
} catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
}
}
throw new IllegalArgumentException("Could not find a URI in the formatted message " + message);
}
public Object getValue(String argumentName) {
Object value = null;
argumentName = argumentName.toLowerCase();
if (parameters.containsKey(argumentName)) {
Argument argument = parameters.get(argumentName);
value = argument.getValue();
if (value == null) {
String defaultValue = argument.getDefaultValue();
try {
value = argument.getHandler().tryArgument(defaultValue);
} catch (Exception e) {
}
}
}
return value;
}
/** Do group units meet group requirements? */
public boolean meetsUnitReqs() {
if (unitTypeReqs.isEmpty()) {
// a group with no requirements always meets requirements.
return true;
} else if (units.isEmpty()) {
// if there are requirments and no units, then group can't meet reqs.
return false;
}
// the above tests are there because
// an empty group has no representative (null representative).
GroupRepresentative rep = getRepresentative();
for (Argument req : unitTypeReqs) {
if (!rep.contains(req.getName(), req.getValue())) {
return false;
}
}
return true;
}
/*
Tries each handler for the given parameter and returns a success boolean
*/
private boolean parseKV(String key, String value) throws Exception {
boolean success = false;
// must have a registered handler; see registerArgumentHandler()
if (!parameters.containsKey(key)) {
throw new Exception(key + " is not a valid argument");
}
Argument arg = parameters.get(key);
// don't allow dupes
if (arg.getValue() != null) {
throw new Exception("Duplicate arguments: " + key);
}
try {
// handler returns null if it can't handle the argument
// it can throw an exception if the argument is an unacceptable value
Object param = arg.getHandler().tryArgument(value);
if (param != null) {
arg.setValue(param);
success = true;
}
} catch (Exception e) {
throw new Exception("Bad argument value for '" + key + "': " + e.getMessage());
}
return success;
}
public OMElement serialize(OMElement parent) {
OMElement payloadFactoryElem = fac.createOMElement(PAYLOAD_FACTORY, synNS);
if (type != null) {
payloadFactoryElem.addAttribute(fac.createOMAttribute(TYPE, nullNS, type));
}
saveTracingState(payloadFactoryElem, this);
if (!dynamic) {
if (format != null) {
try {
OMElement formatElem = fac.createOMElement(FORMAT, synNS);
if (type != null && (type.contains(JSON_TYPE) || type.contains(TEXT_TYPE))) {
formatElem.setText(format);
} else {
formatElem.addChild(AXIOMUtil.stringToOM(format));
}
payloadFactoryElem.addChild(formatElem);
} catch (XMLStreamException e) {
handleException("Error while serializing payloadFactory mediator", e);
}
} else {
handleException("Invalid payloadFactory mediator, format is required");
}
} else {
if (formatKey != null) {
OMElement formatElem = fac.createOMElement(FORMAT, synNS);
formatElem.addAttribute(fac.createOMAttribute("key", nullNS, formatKey));
payloadFactoryElem.addChild(formatElem);
} else {
handleException("Invalid payloadFactory mediator, format is required");
}
}
if (argumentList != null && argumentList.size() > 0) {
OMElement argumentsElem = fac.createOMElement(ARGS, synNS);
for (Argument arg : argumentList) {
OMElement argElem = fac.createOMElement(ARG, synNS);
if (arg.isDeepCheck()) {
argElem.addAttribute(fac.createOMAttribute(DEEP_CHECK, nullNS, "true"));
} else {
argElem.addAttribute(fac.createOMAttribute(DEEP_CHECK, nullNS, "false"));
}
if (arg.getValue() != null) {
argElem.addAttribute(fac.createOMAttribute(VALUE, nullNS, arg.getValue()));
} else if (arg.getExpression() != null) {
SynapseXPathSerializer.serializeXPath(arg.getExpression(), argElem, EXPRESSION);
} else if (arg.getJsonPath() != null) {
argElem.addAttribute(
fac.createOMAttribute(EXPRESSION, nullNS, arg.getJsonPath().getExpression()));
}
// error happens somewhere here
if (arg.getEvaluator() != null) {
argElem.addAttribute(fac.createOMAttribute(EVAL, nullNS, arg.getEvaluator()));
}
argumentsElem.addChild(argElem);
}
payloadFactoryElem.addChild(argumentsElem);
}
if (parent != null) {
parent.addChild(payloadFactoryElem);
}
return payloadFactoryElem;
}
public String toXML() {
Element root = new Element("testCaseTemplateParameter");
for (String importName : imports) {
Element importElement = new Element("import");
importElement.appendChild(importName);
root.appendChild(importElement);
}
for (Map.Entry<String, String> entry : classToMockInstanceNameMap.entrySet()) {
Element classToMockElement = new Element("classToMock");
// ClassName
Element classNameElement = new Element("className");
classNameElement.appendChild(entry.getKey());
classToMockElement.appendChild(classNameElement);
// InstanceName
Element instanceNameElement = new Element("instanceName");
instanceNameElement.appendChild(entry.getValue());
classToMockElement.appendChild(instanceNameElement);
// Invokes
for (String invoke : jMockInvokeSequenceMap.get(entry.getKey())) {
Element invokeElement = new Element("invoke");
invokeElement.appendChild(invoke);
classToMockElement.appendChild(invokeElement);
}
root.appendChild(classToMockElement);
}
Element packageNameElement = new Element("packageName");
packageNameElement.appendChild(this.getPackageName());
root.appendChild(packageNameElement);
Element classUnderTestElement = new Element("classUnderTest");
classUnderTestElement.appendChild(this.getClassUnderTest());
root.appendChild(classUnderTestElement);
for (Argument constructorArgument : constructorArguments) {
Element constructorArgumentElement = new Element("constructorArgument");
Element typeElement = new Element("type");
typeElement.appendChild(constructorArgument.getType());
Element valueElement = new Element("value");
valueElement.appendChild(constructorArgument.getValue());
constructorArgumentElement.appendChild(typeElement);
constructorArgumentElement.appendChild(valueElement);
root.appendChild(constructorArgumentElement);
}
Element methodUnderTestElement = new Element("methodUnderTest");
methodUnderTestElement.appendChild(this.getMethodUnderTest());
root.appendChild(methodUnderTestElement);
for (Parameter methodParameter : methodParameters) {
Element methodParameterElement = new Element("methodParameter");
Element typeElement = new Element("type");
typeElement.appendChild(methodParameter.getType());
Element nameElement = new Element("name");
nameElement.appendChild(methodParameter.getName());
methodParameterElement.appendChild(typeElement);
methodParameterElement.appendChild(nameElement);
root.appendChild(methodParameterElement);
}
Element isStaticMethodElement = new Element("isStaticMethod");
isStaticMethodElement.appendChild("" + this.isStaticMethod());
root.appendChild(isStaticMethodElement);
if (this.isSingleton()) {
Element singletonMethodElement = new Element("singletonMethod");
singletonMethodElement.appendChild(this.getSingletonMethod());
root.appendChild(singletonMethodElement);
}
if (this.hasCheckStateMethod()) {
Element checkStateMethodElement = new Element("checkStateMethod");
checkStateMethodElement.appendChild(this.getCheckStateMethod());
root.appendChild(checkStateMethodElement);
}
Element returnTypeElement = new Element("returnType");
returnTypeElement.appendChild(this.getReturnType());
root.appendChild(returnTypeElement);
if (this.hasDelta()) {
Element deltaElement = new Element("delta");
deltaElement.appendChild("" + this.getDelta());
root.appendChild(deltaElement);
}
Document doc = new Document(root);
return doc.toXML();
}
public String getArgumentValue(String name) {
Argument arg = getArgument(name);
if (arg == null) return "";
return arg.getValue();
}
public boolean actionControlReceived(Action action) {
String actionName = action.getName();
boolean ret = false;
if (actionName.equals("GetPower") == true) {
String state = getPowerState();
Argument powerArg = action.getArgument("Power");
powerArg.setValue(state);
ret = true;
}
if (actionName.equals("SetPower") == true) {
Argument powerArg = action.getArgument("Power");
String state = powerArg.getValue();
setPowerState(state);
state = getPowerState();
Argument resultArg = action.getArgument("Result");
resultArg.setValue(state);
ret = true;
}
comp.repaint();
return ret;
}
