Exemplo n.º 1
0
 /** 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());
   }
 }
Exemplo n.º 2
0
 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;
 }
Exemplo n.º 3
0
 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());
 }
Exemplo n.º 4
0
  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));
  }
Exemplo n.º 5
0
  /** 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());
  }
Exemplo n.º 6
0
 /** 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());
 }