/** 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());
}
/** Test if parameters with expressions are inherited correctly. */
public void testExpressionPropagation() {
// Inheritance: A <- B
Node nodeA = Node.ROOT_NODE.newInstance(testLibrary, "A");
Parameter pF = nodeA.addParameter("f", Parameter.Type.INT, 0);
String expr1 = "12 + 5";
pF.setExpression(expr1);
Node nodeB = nodeA.newInstance(testLibrary, "B");
assertEquals(expr1, nodeB.getParameter("f").getExpression());
// Changing the expression of A does not automatically change that of B.
String expr2 = "4 * 2";
pF.setExpression(expr2);
assertEquals(expr1, nodeB.getParameter("f").getExpression());
// Reverting to default does.
nodeB.getParameter("f").revertToDefault();
assertEquals(expr2, nodeB.getParameter("f").getExpression());
}
/**
* Test the hasStampExpression on the node.
*
* <p>This method is used to determine if parameters/nodes should be marked as dirty when
* re-evaluating upstream, which is what happens in the copy node.
*/
public void testHasStampExpression() {
Node n = Node.ROOT_NODE.newInstance(testLibrary, "test");
Parameter pAlpha = n.addParameter("alpha", Parameter.Type.FLOAT);
Parameter pBeta = n.addParameter("beta", Parameter.Type.FLOAT);
assertFalse(n.hasStampExpression());
// Set the parameters to expressions that do not use the stamp function.
pAlpha.setExpression(" 12 + 5");
pBeta.setExpression("random(1, 5, 10)");
assertFalse(n.hasStampExpression());
// Set one of the parameters to the stamp function.
pBeta.setExpression("stamp(\"mybeta\", 42)");
assertTrue(n.hasStampExpression());
// Set the other parameter expression to a stamp function as well.
pAlpha.setExpression("stamp(\"myalpha\", 0) * 5");
assertTrue(n.hasStampExpression());
// Clear out the expressions one by one.
pAlpha.clearExpression();
assertTrue(n.hasStampExpression());
// Change the beta parameter to some other expression.
pBeta.setExpression("85 - 6");
assertFalse(n.hasStampExpression());
}
