/** Test if errors with expressions also set the error flag on the node. */ public void testExpressionError() { Node n = numberNode.newInstance(testLibrary, "number1"); n.setExpression("value", "***"); try { n.update(); fail("Should have caused an exception."); } catch (ProcessingError e) { assertTrue(e.getCause().toString().toLowerCase().contains("cannot compile expression")); assertTrue(n.hasError()); // As stated in Node#update(ProcessingContext), even if an error occurred the node is still // marked as clean // and events are fired. It is important to mark the node as clean so that subsequent changes // to the node // mark it as dirty, triggering an event. This allows you to fix the cause of the error in the // node. assertFalse(n.isDirty()); assertNull(n.getOutputValue()); } n.setExpression("value", "10 + 1"); assertTrue(n.isDirty()); n.update(); assertFalse(n.hasError()); assertFalse(n.isDirty()); assertEquals(11, n.getOutputValue()); }
/** 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 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()); }
private void runSimulation(Node leaf) { Board board = (Board) DeepCopy.copy(leaf.board); // Keep track of all moves made for RAVE updates boolean[][][] moves = new boolean[board.size][board.size][3]; Move m1, m2; Point p1, p2; while (true) { m1 = simPolicy.getMove(board); p1 = (m1 == null ? null : m1.point); board.addStone(board.turn, p1); if (p1 != null) { moves[p1.x][p1.y][board.turn.ordinal()] = true; board.prevAtariedChains = m1.simFeatures.prevAtariedChains; board.prevTwoLibbedChains = m1.simFeatures.prevTwoLibbedChains; } // board.printBoard(); // System.out.println(); // board.printLiberties(); // board.printLegalMoves(); // System.out.println(board.turn); m2 = simPolicy.getMove(board); p2 = (m2 == null ? null : m2.point); board.addStone(board.turn, p2); if (p2 != null) { moves[p2.x][p2.y][board.turn.ordinal()] = true; board.prevAtariedChains = m2.simFeatures.prevAtariedChains; board.prevTwoLibbedChains = m2.simFeatures.prevTwoLibbedChains; } // board.printBoard(); // System.out.println(); // board.printLiberties(); // board.printLegalMoves(); // System.out.println(board.turn); if (p1 == null && p2 == null) break; } Score score = new Score(board); if (score.whiteScore > score.blackScore) { synchronized (lock) { leaf.update(Color.WHITE, board, moves); } } else { synchronized (lock) { leaf.update(Color.BLACK, board, moves); } } }
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()); }
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); }
private void checkNodeValidity(@NotNull DefaultMutableTreeNode node) { Enumeration enumeration = node.children(); while (enumeration.hasMoreElements()) { checkNodeValidity((DefaultMutableTreeNode) enumeration.nextElement()); } if (node instanceof Node && node != getModelRoot()) ((Node) node).update(this); }
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")); }
Node ensureMaster() { Node n = getMasterNode(); if (n != null) { n.update(); if (n._isMaster) return n; } if (_lastPrimarySignal != null) { n = findNode(_lastPrimarySignal); n.update(); if (n._isMaster) return n; } updateAll(); return getMasterNode(); }
/** * Updates the game state to the next tick. First applies the messages past in as arguments, then * updates the nodes, then the lanes, then checks for a winning player. * * @param messages the messages to apply for this game state tick */ public void update(Message[] messages) { this.validateLock(); for (Message m : messages) m.apply(this); this.validateLock(); for (Node n : map.getNodes()) n.update(); this.validateLock(); for (Lane l : map.getLanes()) l.update(); this.validateLock(); double energyToAdd = ENERGY_INCREMENT_RATE * this.getLastLoopTime(); for (Player p : players.values()) { p.setPlayerEnergy(p.getPlayerEnergy() + energyToAdd); if (p.getPlayerEnergy() > MAX_PLAYER_ENERGY) p.setPlayerEnergy(MAX_PLAYER_ENERGY); } timerTick++; lastLoopTime = this.getTime() - timeAtEndOfLastLoop; timeAtEndOfLastLoop = this.getTime(); this.validateLock(); // check for win Node n1 = map.getNodes()[0]; for (Node n : map.getNodes()) if (n1.getOwner() == null || !n1.getOwner().equals(n.getOwner())) return; winningPlayer = n1.getOwner(); }
/** * Performs a single left rotation: a s / \ / \ T1 s => a T3 / \ / \ T2 T3 T1 T2 * * @param a The rotation anchor. * @return The new anchor node. */ private Node rotateLeft(Node a) { Node s = a.right; System.out.printf(" -> Left single rotation on elements a: %d, s: %d%n", a.value, s.value); if (a == root) s.setRoot(); else a.parent.replace(a, s); a.setRight(s.left); a.update(); s.setLeft(a); s.update(); return s; }
/** * Test the behaviour of {@link Node#stampDirty()}. * * @throws ExpressionError if the expression causes an error. This indicates a regression. */ public void testMarkStampedDirty() throws ExpressionError { // Setup a graph where a <- b <- c. Node a = Node.ROOT_NODE.newInstance(testLibrary, "a", Integer.class); Node b = Node.ROOT_NODE.newInstance(testLibrary, "b", Integer.class); Node c = Node.ROOT_NODE.newInstance(testLibrary, "c", Integer.class); a.addParameter("a", Parameter.Type.INT); b.addParameter("b", Parameter.Type.INT); Port bIn = b.addPort("in"); Port cIn = c.addPort("in"); bIn.connect(a); cIn.connect(b); // Update the graph. This will make a, b and c clean. c.update(); assertFalse(a.isDirty()); assertFalse(b.isDirty()); assertFalse(c.isDirty()); // Set b to a stamped expression. This will make node b, and all of its dependencies, dirty. b.setExpression("b", "stamp(\"my_b\", 55)"); assertTrue(b.hasStampExpression()); assertFalse(a.isDirty()); assertTrue(b.isDirty()); assertTrue(c.isDirty()); // Update the graph, cleaning all of the nodes. c.update(); assertFalse(a.isDirty()); assertFalse(b.isDirty()); assertFalse(c.isDirty()); // Mark only stamped upstream nodes as dirty. This will make b dirty, and all of its // dependencies. c.stampDirty(); assertFalse(a.isDirty()); assertTrue(b.isDirty()); assertTrue(c.isDirty()); // Remove the expression and update. This will make all nodes clean again. b.clearExpression("b"); c.update(); // Node b will not be dirty, since everything was updated. assertFalse(b.isDirty()); // Since there are no nodes with stamp expressions, marking the stamped upstream nodes will have // no effect. c.stampDirty(); assertFalse(a.isDirty()); assertFalse(b.isDirty()); assertFalse(c.isDirty()); }
/** 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()); }
/** This is the same test as ParameterTest#testExpressionDependencies, but at the Node level. */ public void testRemoveExpressionDependency() { Node net = testNetworkNode.newInstance(testLibrary, "net"); Node number1 = net.create(numberNode); number1.addParameter("bob", Parameter.Type.INT, 10); number1.setExpression("value", "bob"); number1.setRendered(); net.update(); assertEquals(10, net.getOutputValue()); number1.removeParameter("bob"); try { net.update(); fail(); } catch (ProcessingError e) { assertTrue(e.getCause().getMessage().toLowerCase().contains("cannot evaluate expression")); } assertTrue(net.hasError()); assertTrue(number1.hasError()); assertNull(net.getOutputValue()); }
public void testBaseNode() { Node baseNode = Node.ROOT_NODE; Parameter pCode = baseNode.getParameter("_code"); Parameter pHandle = baseNode.getParameter("_handle"); assertEquals("_code", pCode.getName()); assertEquals(Parameter.Type.CODE, pCode.getType()); assertEquals("_handle", pHandle.getName()); assertEquals(Parameter.Type.CODE, pHandle.getType()); baseNode.update(); assertNull(baseNode.getOutputValue()); }
// rotates edge (x, x.parent) // g g // / / // p x // / \ -> / \ // x p.r x.l p // / \ / \ // x.l x.r x.r p.r static void rotate(Node x) { Node p = x.parent; Node g = p.parent; boolean isRootP = p.isRoot(); boolean leftChildX = (x == p.left); // create 3 edges: (x.r(l),p), (p,x), (x,g) connect(leftChildX ? x.right : x.left, p, leftChildX); connect(p, x, !leftChildX); connect(x, g, !isRootP ? p == g.left : null); p.update(); }
// brings x to the root, balancing tree // // zig-zig case // g x // / \ p / \ // p g.r rot(p) / \ rot(x) x.l p // / \ --> x g --> / \ // x p.r / \ / \ x.r g // / \ x.l x.r p.r g.r / \ // x.l x.r p.r g.r // // zig-zag case // g g // / \ / \ x // p g.r rot(x) x g.r rot(x) / \ // / \ --> / \ --> p g // p.l x p x.r / \ / \ // / \ / \ p.l x.l x.r g.r // x.l x.r p.l x.l static void splay(Node x) { while (!x.isRoot()) { Node p = x.parent; Node g = p.parent; if (!p.isRoot()) g.push(); p.push(); x.push(); if (!p.isRoot()) rotate((x == p.left) == (p == g.left) ? p /*zig-zig*/ : x /*zig-zag*/); rotate(x); } x.push(); x.update(); }
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()); }
/** * Performs a double right rotation: a b / \ / \ s T4 s a / \ => / \ / \ T1 b T1 T2 T3 T4 / \ T2 * T3 * * @param a The rotation anchor. * @return The new anchor node. */ private Node rotateRightDouble(Node a) { Node s = a.left; Node b = s.right; System.out.printf( " -> Double right rotation on elements a: %d, s: %d, b: %d%n", a.value, s.value, b.value); if (a == root) b.setRoot(); else a.parent.replace(a, b); a.setLeft(b.right); a.update(); s.setRight(b.left); s.update(); b.setRight(a); b.setLeft(s); b.update(); return b; }
/** Test if errors with dependencies fail fast, and have the correct error behaviour. */ public void testDependencyError() { Node net = testNetworkNode.newInstance(testLibrary, "net"); Node negate1 = net.create(negateNode); Node crash1 = net.create(crashNode); negate1.getPort("value").connect(crash1); try { negate1.update(); } catch (ProcessingError e) { // The error flag is limited to the dependency that caused the error. // The crash node caused the error, so it has the error flag, // but the dependent node, negate1, doesn't get the error flag. assertTrue(crash1.hasError()); assertFalse(negate1.hasError()); } }
synchronized void updateAll() { HashSet<Node> seenNodes = new HashSet<Node>(); for (int i = 0; i < _all.size(); i++) { Node n = _all.get(i); n.update(seenNodes); } if (!seenNodes.isEmpty()) { // not empty, means that at least 1 server gave node list // remove unused hosts Iterator<Node> it = _all.iterator(); while (it.hasNext()) { if (!seenNodes.contains(it.next())) it.remove(); } } }
/** * Walks up from the most recent deleted item to the tree root in order to inform all entities * * @param a The current node that has to be revalidated after a tree alteration. */ private void up(Node a) { Node next = a.parent; int orgHeigth = a.height; System.out.printf( "Validating element: %d (balance/height: %d, %d =>", a.value, a.balance, a.height); a.update(); System.out.printf(" %d, %d)%n", a.balance, a.height); // Check if tree node is out of balance. if (Math.abs(a.balance) >= 2) a = rotate(a); // Update parent nodes only if the tree root was not yet reached // and if the height of the current node was altered. if (next != null && orgHeigth != a.height) up(next); }
/** Updates this renderable node */ @Override public void update() { if (renderTarget != null) renderTarget.update(); super.update(); }
/** * Removes an element from the tree. * * @param val The value. */ public void remove(int val) { Node k = findNode(root, val); if (k == null) throw new IllegalArgumentException( "Cannot remove " + val + " because such a node does not exist."); Node kParent = k.parent; System.out.printf("Removing value: %d%n", val); // Delete node that is a leaf. if (k.isLeaf()) { System.out.println(" -> Corresponding node is a leaf : Performing cutoff."); if (k == root) root = null; else k.parent.removeSon(k); // Delete node that us a single son. } else if (k.isSingleSon()) { System.out.println( " -> Corresponding node has only one son. Connecting node's son and parent."); if (k == root) k.onlySon().setRoot(); else k.parent.replace(k, k.onlySon()); // Delete inner node. } else { // Check if it is more efficient to exchange node by another left or right side node // If uncertain, choose right side (and thus bigger element) for finding a replacement. boolean replaceByLeft = k.left != null && (k.right == null || k.left.height > k.right.height); Node s; if (replaceByLeft) s = findNextSmallerNode(k); else s = findNextBiggerNode(k); System.out.printf( " -> Correspondig node has two sons. Removing next %s element from tree first" + " before proceeding. Removing: %d%n", replaceByLeft ? "bigger" : "smaller", s.value); // Remove node first that is to be used as a replacement. remove(s.value); System.out.printf(" -> %d is removed. Proceeding with replacing %d%n", s.value, k.value); // Set new node in place of the removed node. if (k == root) s.setRoot(); else k.parent.replace(k, s); // Fix father - son relationships. s.setLeft(k.left); s.setRight(k.right); s.update(); } if (kParent != null) up(kParent); }
public MemoNode update(String value) { myNode = myNode.update(value); return myNode; }