/** 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()); } }
private Node<?> node() throws IOException { chunk("NODE"); animations.push(HashBasedTable.<Integer, Optional<Node<?>>, Key>create()); Triple<Integer, Integer, Float> animData = null; Pair<Brush, List<Face>> mesh = null; List<Pair<Vertex, Float>> bone = null; Map<Integer, Key> keys = new HashMap<Integer, Key>(); List<Node<?>> nodes = new ArrayList<Node<?>>(); String name = readString(); Vector3f pos = new Vector3f(buf.getFloat(), buf.getFloat(), buf.getFloat()); Vector3f scale = new Vector3f(buf.getFloat(), buf.getFloat(), buf.getFloat()); Quat4f rot = readQuat(); dump("NODE(" + name + ", " + pos + ", " + scale + ", " + rot + ") {"); while (buf.hasRemaining()) { readHeader(); if (isChunk("MESH")) mesh = mesh(); else if (isChunk("BONE")) bone = bone(); else if (isChunk("KEYS")) keys.putAll(keys()); else if (isChunk("NODE")) nodes.add(node()); else if (isChunk("ANIM")) animData = anim(); else skip(); } dump("}"); popLimit(); Table<Integer, Optional<Node<?>>, Key> keyData = animations.pop(); Node<?> node; if (mesh != null) { Node<Mesh> mNode = Node.create(name, pos, scale, rot, nodes, new Mesh(mesh)); meshes.put(name, mNode); node = mNode; } else if (bone != null) node = Node.create(name, pos, scale, rot, nodes, new Bone(bone)); else node = Node.create(name, pos, scale, rot, nodes, new Pivot()); if (animData == null) { for (Table.Cell<Integer, Optional<Node<?>>, Key> key : keyData.cellSet()) { animations .peek() .put(key.getRowKey(), key.getColumnKey().or(Optional.of(node)), key.getValue()); } } else { node.setAnimation(animData, keyData); } return node; }
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 testCopyWithUpstream() { Node net = testNetworkNode.newInstance(testLibrary, "net1"); Node number1 = net.create(numberNode); Node number2 = net.create(numberNode); Node add1 = net.create(addNode); assertEquals("number1", number1.getName()); assertEquals("number2", number2.getName()); assertEquals("add1", add1.getName()); add1.getPort("v1").connect(number1); add1.getPort("v2").connect(number2); // TODO: Implement copyNodeWithUpstream // Node copiedAdd1 = add1.getParent().copyNodeWithUpstream(add1); // assertEquals("add1", copiedAdd1.getName()); // Network copiedNetwork = copiedAdd1.getParent(); // assertEquals(net.getName(), copiedNetwork.getName()); // Node copiedNumber1 = copiedAdd1.getParent().get("number1"); // Node copiedNumber2 = copiedAdd1.getParent().get("number2"); // assertNotNull(copiedNumber1); // assertNotNull(copiedNumber2); // assert (copiedAdd1.isConnected()); // assert (copiedAdd1.getParameter("v1").isConnectedTo(copiedNumber1)); // assert (copiedAdd1.getParameter("v2").isConnectedTo(copiedNumber2)); }
/** 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()); }