public void testError() {
Node bad = addDirectNode.newInstance(testLibrary, "bad");
TestDirtyListener listener = new TestDirtyListener();
bad.addDirtyListener(listener);
bad.setValue("v1", 12);
bad.setValue("v2", 3);
// Since the node starts out as dirty, setting values doesn't increase the counter.
assertEquals(0, listener.dirtyCounter);
// This code inherits the default code, which doesn't throw an error.
bad.update();
assertEquals(15, bad.getOutputValue());
// Updating the code marks it as clean.
assertFalse(bad.isDirty());
assertEquals(1, listener.updatedCounter);
assertEquals(0, listener.dirtyCounter);
// This code causes a division by zero.
bad.setValue("_code", new PythonCode("def cook(self):\n return 1 / 0"));
assertEquals(1, listener.dirtyCounter);
// We just changed a parameter value, so the node is dirty.
assertTrue(bad.isDirty());
// Processing will fail.
assertProcessingError(bad, "integer division or modulo by zero");
// After processing failed, events are still called,
// and the node is marked clean. Output is set to null.
assertFalse(bad.isDirty());
assertNull(bad.getOutputValue());
assertEquals(2, listener.updatedCounter);
assertEquals(1, listener.dirtyCounter);
}
public void testBasicUsage() {
Node dotNode = Node.ROOT_NODE.newInstance(testLibrary, "dotNode");
dotNode.addParameter("x", Parameter.Type.FLOAT);
dotNode.addParameter("y", Parameter.Type.FLOAT);
dotNode.setValue("_code", new JavaMethodWrapper(getClass(), "_dot"));
dotNode.addParameter("_output", Parameter.Type.STRING);
// Check default values
assertEquals(0F, dotNode.getValue("x"));
assertEquals(0F, dotNode.getValue("y"));
assertEquals("", dotNode.getValue("_output"));
// Process
dotNode.update();
assertEquals("dot(0.0,0.0)", dotNode.getOutputValue());
// Create instance and change values
Node dotInstance = dotNode.newInstance(testLibrary, "dotInstance");
dotInstance.setValue("x", 25F);
dotInstance.setValue("y", 42F);
dotInstance.update();
assertEquals("dot(25.0,42.0)", dotInstance.getOutputValue());
// Check that original hasn't changed
assertEquals(0F, dotNode.asFloat("x"));
assertEquals(0F, dotNode.asFloat("y"));
assertEquals("dot(0.0,0.0)", dotNode.getOutputValue());
// Now let the instance use its own code
dotInstance.setValue("_code", new JavaMethodWrapper(getClass(), "_dot2"));
dotInstance.update();
assertEquals("dot2(25.0,42.0)", dotInstance.getOutputValue());
}
public boolean save() {
Node node = ForumManager.getCloud().getNode(id);
node.setValue("mode", mode);
node.setValue("body", body);
node.setValue("encoding", encoding);
node.commit();
return true;
}
public void testMMB1546() {
Cloud cloud = getCloud();
Transaction t = cloud.getTransaction("test0");
Node nt = t.getNode(newNode);
nt.setValue("title", "bla");
// t.cancel(); _DONT_ cancel
Node nc = cloud.getNode(newNode);
nc.setValue("title", "bloe");
nc.commit();
assertEquals("bloe", nc.getStringValue("title"));
assertEquals("bloe", cloud.getNode(newNode).getStringValue("title"));
t.cancel();
assertEquals("bloe", cloud.getNode(newNode).getStringValue("title"));
}
/** Test if setting a stamp expressions marks the correct nodes as dirty. */
public void testStampExpression() {
Node number1 = numberNode.newInstance(testLibrary, "number1");
Node stamp1 = Node.ROOT_NODE.newInstance(testLibrary, "stamp1", Integer.class);
stamp1.addPort("value");
stamp1.getPort("value").connect(number1);
// The code prepares upstream dependencies for stamping, processes them and negates the output.
String stampCode =
"def cook(self):\n"
+ " context.put('my_a', 99)\n"
+ " self.node.stampDirty()\n"
+ " self.node.updateDependencies(context)\n"
+ " return -self.value # Negate the output";
stamp1.setValue("_code", new PythonCode(stampCode));
Parameter pValue = number1.getParameter("value");
// Set number1 to a regular value. This should not influence the stamp operation.
pValue.set(12);
stamp1.update();
assertEquals(-12, stamp1.getOutputValue());
// Set number1 to an expression. Since we're not using stamp, nothing strange should happen to
// the output.
pValue.setExpression("2 + 1");
stamp1.update();
assertEquals(-3, stamp1.getOutputValue());
// Set number1 to an unknown stamp expression. The default value will be picked.
pValue.setExpression("stamp(\"xxx\", 19)");
stamp1.update();
assertEquals(-19, stamp1.getOutputValue());
// Set number1 to the my_a stamp expression. The expression will be picked up.
pValue.setExpression("stamp(\"my_a\", 33)");
stamp1.update();
assertEquals(-99, stamp1.getOutputValue());
}
public void testBasicClone() {
Node myNode = Node.ROOT_NODE.newInstance(testLibrary, "myNode");
myNode.setValue("_code", new JavaMethodWrapper(getClass(), "_addParameter"));
myNode.update();
assertTrue(myNode.hasParameter("myparam"));
assertEquals("myvalue", myNode.getValue("myparam"));
}
public void testSetValue() {
// Inheritance: A <- B <- C
Node nodeA = Node.ROOT_NODE.newInstance(testLibrary, "A");
nodeA.addParameter("a", Parameter.Type.FLOAT, 1F);
Node nodeB = nodeA.newInstance(testLibrary, "B");
nodeB.addParameter("b", Parameter.Type.FLOAT, 2F);
Node nodeC = nodeB.newInstance(testLibrary, "C");
nodeC.addParameter("c", Parameter.Type.FLOAT, 3F);
nodeC.setValue("a", 10F);
nodeC.setValue("b", 20F);
nodeC.setValue("c", 30F);
assertEquals(1F, nodeA.asFloat("a"));
assertEquals(2F, nodeB.asFloat("b"));
assertEquals(10F, nodeC.asFloat("a"));
assertEquals(20F, nodeC.asFloat("b"));
assertEquals(30F, nodeC.asFloat("c"));
}
/** Test if print messages get output. */
public void testOutput() {
ProcessingContext ctx;
PythonCode helloCode = new PythonCode("def cook(self): print 'hello'");
Node test = Node.ROOT_NODE.newInstance(testLibrary, "test");
test.setValue("_code", helloCode);
ctx = new ProcessingContext();
test.update(ctx);
assertEquals("hello\n", ctx.getOutput());
// Try this in a network. All the output of the nodes should be merged.
Node parent = Node.ROOT_NODE.newInstance(testLibrary, "parent");
Node child = parent.create(Node.ROOT_NODE, "child");
child.setValue("_code", helloCode);
child.setRendered();
ctx = new ProcessingContext();
parent.update(ctx);
assertEquals("hello\n", ctx.getOutput());
}
////////////////////////////////////////////////
// createFaultResponseNode
////////////////////////////////////////////////
private Node createFaultResponseNode(int errCode, String errDescr) {
// <s:Fault>
Node faultNode = new Node(SOAP.XMLNS + SOAP.DELIM + SOAP.FAULT);
// <faultcode>s:Client</faultcode>
Node faultCodeNode = new Node(SOAP.FAULT_CODE);
faultCodeNode.setValue(SOAP.XMLNS + SOAP.DELIM + FAULT_CODE);
faultNode.addNode(faultCodeNode);
// <faultstring>UPnPError</faultstring>
Node faultStringNode = new Node(SOAP.FAULT_STRING);
faultStringNode.setValue(FAULT_STRING);
faultNode.addNode(faultStringNode);
// <detail>
Node detailNode = new Node(SOAP.DETAIL);
faultNode.addNode(detailNode);
// <UPnPError xmlns="urn:schemas-upnp-org:control-1-0">
Node upnpErrorNode = new Node(FAULT_STRING);
upnpErrorNode.setAttribute("xmlns", Control.XMLNS);
detailNode.addNode(upnpErrorNode);
// <errorCode>error code</errorCode>
Node errorCodeNode = new Node(SOAP.ERROR_CODE);
errorCodeNode.setValue(errCode);
upnpErrorNode.addNode(errorCodeNode);
// <errorDescription>error string</errorDescription>
Node errorDesctiprionNode = new Node(SOAP.ERROR_DESCRIPTION);
errorDesctiprionNode.setValue(errDescr);
upnpErrorNode.addNode(errorDesctiprionNode);
return faultNode;
}
public void testDisconnect() {
Node net1 = testNetworkNode.newInstance(testLibrary, "net1");
Node number1 = net1.create(numberNode);
Node number2 = net1.create(numberNode);
Node multiAdd1 = net1.create(multiAddNode);
number1.setValue("value", 5);
number2.setValue("value", 8);
multiAdd1.getPort("values").connect(number1);
multiAdd1.getPort("values").connect(number2);
multiAdd1.update();
assertFalse(multiAdd1.isDirty());
assertEquals(2, multiAdd1.getPort("values").getValues().size());
assertEquals(13, multiAdd1.getOutputValue());
multiAdd1.disconnect();
assertTrue(multiAdd1.isDirty());
assertFalse(multiAdd1.isConnected());
assertFalse(number1.isConnected());
assertFalse(number2.isConnected());
multiAdd1.update();
assertEquals(0, multiAdd1.getPort("values").getValues().size());
assertEquals(0, multiAdd1.getOutputValue());
}
public void insertAfter(Node node, Object object) {
Node newNode = new Node();
node.setValue(object);
int before = node.getAfter() + 1 <= size() ? node.getAfter() + 1 : -1;
int after = node.getAfter() - 1;
node.setBefore(before);
node.setAfter(after);
list.add(node.getAfter(), newNode);
for (int i = node.getAfter() + 1; i < size(); i++) {
get(i).setAfter(get(i).getAfter() + 1);
get(i).setBefore(get(i).getBefore() + 1);
}
}
public boolean push(T item) {
boolean result = false;
Node<T> node = new Node<T>();
node.setValue(item);
if (head == null) {
head = node;
result = true;
} else {
node.setNextNode(head);
head = node;
}
size++;
return result;
}
public void testDirty() {
Node n = numberNode.newInstance(testLibrary, "number1");
assertTrue(n.isDirty());
n.update();
assertFalse(n.isDirty());
n.setValue("value", 12);
assertTrue(n.isDirty());
n.update();
assertFalse(n.isDirty());
n.getParameter("value").set(13);
assertTrue(n.isDirty());
n.update();
assertFalse(n.isDirty());
}
private Node createPropertySetNode(String varName, String value) {
Node propSetNode = new Node(/*XMLNS + SOAP.DELIM + */ PROPERTYSET);
propSetNode.setNameSpace(XMLNS, Subscription.XMLNS);
Node propNode = new Node(/*XMLNS + SOAP.DELIM + */ PROPERTY);
propSetNode.addNode(propNode);
// Thanks for Giordano Sassaroli <*****@*****.**> (05/22/03)
// Node varNameNode = new Node(XMLNS + SOAP.DELIM + varName);
Node varNameNode = new Node(varName);
varNameNode.setValue(value);
propNode.addNode(varNameNode);
return propSetNode;
}
/**
* Replaces the
*
* @param index
* @param value
* @return
*/
public Builder set(int index, SEXP value) {
if (index < 0) {
throw new IndexOutOfBoundsException("index must be > 0");
}
if (head == null) {
add(Null.INSTANCE);
}
Node node = head;
int nodeIndex = 0;
while (nodeIndex != index) {
if (node.nextNode == Null.INSTANCE) {
add(Null.INSTANCE);
}
node = node.getNextNode();
nodeIndex++;
}
node.setValue(value);
return this;
}
/** Test propagation behaviour for parameters. */
public void testParameterPropagation() {
// Inheritance: A <- B
Node nodeA = Node.ROOT_NODE.newInstance(testLibrary, "A");
nodeA.addParameter("f", Parameter.Type.FLOAT, 1F);
Node nodeB = nodeA.newInstance(testLibrary, "B");
// The parameters of A and B are not the same.
assertNotSame(nodeA.getParameter("f"), nodeB.getParameter("f"));
nodeA.setValue("f", 10F);
// The value for the B parameter doesn't automatically change when A was changed.
assertEquals(10F, nodeA.asFloat("f"));
assertEquals(1F, nodeB.asFloat("f"));
// Setting the value of B does not affect the value of A.
nodeB.getParameter("f").setValue(55F);
assertEquals(10F, nodeA.asFloat("f"));
assertEquals(55F, nodeB.asFloat("f"));
// Reverting to the default value will force B to load the new parameter value
// from the prototype.
nodeB.getParameter("f").revertToDefault();
assertEquals(10F, nodeB.asFloat("f"));
}
public int findBestMove(Node currentNode, int best) {
int turn = currentNode.getBoard().CurrentPlayer();
// set the current value of the current node to compare with children node
if (turn != player) currentNode.setValue(Float.POSITIVE_INFINITY);
else currentNode.setValue(Float.NEGATIVE_INFINITY);
// Check each pit on your side to find the best move. */
for (int i = 0; i < 6; i++)
if (currentNode.getBoard().validMove(i)) {
try {
MancalaGameState newBoard = currentNode.getBoard().copy();
try {
newBoard.play(i);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Node newNode = new Node(newBoard, currentNode.getDepth() + 1);
newNode.setParent(currentNode);
currentNode.setChild(newNode, i);
// CUT OFF
if (newNode.getBoard().checkEndGame() || (newNode.getDepth() >= cutoffDepth)) {
RegressionState aState = new RegressionState(newNode.getBoard(), player);
newNode.setValue(predictedValue(aState, weight));
} else findBestMove(newNode, best);
// alpha-beta pruning
// AI = MAX
// pick the child with larger value
if (currentNode.getBoard().CurrentPlayer() == player) {
if (currentNode.getChild(i) != null) {
if (currentNode.getChild(i).getValue() > currentNode.getValue()) {
currentNode.setValue(currentNode.getChild(i).getValue());
best = i;
}
}
currentNode.deleteChild(i);
// alpha cut off if our value is greater than ANY
// player/MIN parent value
Node nodePtr = currentNode;
while (nodePtr.getParent() != null) {
nodePtr = nodePtr.getParent();
if ((nodePtr.getBoard().CurrentPlayer != player)
&& (currentNode.getValue() > nodePtr.getValue())) {
nodePtr = null;
return best;
}
}
nodePtr = null;
}
// Player = MIN
// pick the child with smaller value
if (currentNode.getBoard().CurrentPlayer() != player) {
if (currentNode.getChild(i) != null) {
if (currentNode.getChild(i).getValue() < currentNode.getValue()) {
currentNode.setValue(currentNode.getChild(i).getValue());
best = i;
}
}
currentNode.deleteChild(i);
// beta cut off if our value is less than ANY
// computer/MAX parent value
Node nodePtr = currentNode;
while (nodePtr.getParent() != null) {
nodePtr = nodePtr.getParent();
if ((nodePtr.getBoard().CurrentPlayer() == player)
&& (currentNode.getValue() < nodePtr.getValue())) {
nodePtr = null;
return best;
}
}
nodePtr = null;
}
} catch (java.lang.OutOfMemoryError e) {
System.out.println("OUT OF MEM");
return -1;
}
}
return best; // return the best move
}
private Boolean sendMail(HttpServletRequest req, Node node, String email) {
boolean send = false;
Cloud cloud = node.getCloud();
String emailbuilder = "email";
try {
Module sendmail = cloud.getCloudContext().getModule("sendmail");
emailbuilder = sendmail.getProperty("emailbuilder");
} catch (NotFoundException nfe) {
log.warn("No email module " + nfe);
}
if (cloud.hasNodeManager(emailbuilder)) {
NodeManager nm = cloud.getNodeManager(emailbuilder);
Node message = nm.createNode();
String host = req.getHeader("host");
if (host == null || "".equals(host)) {
try {
host = java.net.InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException uhe) {
log.warn("No host: " + uhe);
}
}
String from = "downloader@" + host;
// do a quick check if we've got something more or less valid
Pattern p = Pattern.compile(".+@.+\\.[a-z]+");
Matcher m = p.matcher(from);
if (!m.matches()) {
from = "*****@*****.**";
}
String mediaTitle = node.getStringValue("title");
String mediaUrl = getProperty(node, URL_KEY);
StringBuilder body = new StringBuilder();
body.append("*This is an automated message / Dit is een geautomatiseerd bericht*");
body.append("\n\n*English*");
body.append("\n\nDear,");
body.append("\n\nWe have received your file belonging to media item titled '")
.append(mediaTitle)
.append("'. ");
body.append("In about 1 hour, you can find your submission at: ");
body.append("http://").append(host).append("/media/").append(node.getNumber());
body.append("\n\nKind regards,");
body.append("\n\n").append(host);
body.append("\n\n\n*Nederlands*");
body.append("\n\nBeste,");
body.append("\n\nWe hebben je bestand voor het media item met de titel '")
.append(mediaTitle)
.append("' ontvangen. ");
body.append("Je kunt je bijdrage hier over circa een uur terugvinden: ");
body.append("http://").append(host).append("/media/").append(node.getNumber());
body.append("\n\nMet vriendelijke groet,");
body.append("\n\n").append(host);
message.setValue("from", from);
message.setValue("to", email);
message.setValue("subject", "Download complete / Download voltooid");
message.setValue("body", body.toString());
message.commit();
Function mail = message.getFunction("mail");
Parameters mail_params = mail.createParameters();
mail_params.set("type", "oneshot");
mail.getFunctionValue(mail_params);
if (log.isDebugEnabled()) {
log.debug("Message download ready send to: " + email);
}
send = true;
} else {
log.warn("Can not send message - no emailbuilder installed.");
}
return send;
}
public Node add(Integer value) {
Node node = new Node();
node.setValue(value);
return add(node);
}
/**
* Update the value in position
*
* @param position
* @param element
*/
public void set(int position, T element) {
Node<T> node = getNode(position);
node.setValue(element);
}
