(function() {
    'use strict';
  
    module('Node');
  
    test('constructor, properties, and getters', function() {
      var node1 = new DivSugar.Node('node1');
      ok(node1.div instanceof HTMLDivElement);
      strictEqual(node1.div.id, 'node1');
      strictEqual(node1.div.sugar, node1);
      strictEqual(node1.getParent(), null);
      strictEqual(node1.getWidth(), 0);
      strictEqual(node1.getHeight(), 0);
      strictEqual(node1.getPositionX(), 0);
      strictEqual(node1.getPositionY(), 0);
      strictEqual(node1.getPositionZ(), 0);
      strictEqual(node1.getVisible(), true);
      strictEqual(node1.getBackface(), true);
      strictEqual(node1.getClip(), false);
      strictEqual(node1.getOpacity(), 1);
      strictEqual(node1.getImage(), null);
      strictEqual(node1.getImageClipU1(), 0);
      strictEqual(node1.getImageClipV1(), 0);
      strictEqual(node1.getImageClipU2(), 1);
      strictEqual(node1.getImageClipV2(), 1);
  
      var node2 = new DivSugar.Scene();
      strictEqual(node2.div.id, '');
    });
  
    test('append', function() {
      var node1 = new DivSugar.Node();
      var node2 = new DivSugar.Node();
      node1.append(node2);
      strictEqual(node2.getParent(), node1);
  
      ok(node1.append(node2).append(node2));
    });
  
    test('appendTo', function() {
      var node1 = new DivSugar.Node();
      var node2 = new DivSugar.Node();
      node1.appendTo(node2);
      strictEqual(node1.getParent(), node2);
  
      ok(node1.appendTo(node2).appendTo(node2));
    });
  
    test('remove', function() {
      var node1 = new DivSugar.Node();
      var node2 = new DivSugar.Node();
      node1.append(node2);
      node1.remove(node2);
      strictEqual(node2.getParent(), null);
  
      ok(node1.remove(node2).remove(node2));
    });
  
    test('getPosition', function() {
      var vec = new DivSugar.Vector(1, 2, 3);
      var node = new DivSugar.Node();
      node.getPosition(vec);
      deepEqual(vec, DivSugar.Vector.ZERO);
  
      ok(node.getPosition(vec).getPosition(vec));
    });
  
    test('getTransform', function() {
      var mat = new DivSugar.Matrix(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
      var node = new DivSugar.Node();
      node.getTransform(mat);
      deepEqual(mat, DivSugar.Matrix.UNIT);
  
      ok(node.getTransform(mat).getTransform(mat));
    });
  
    test('setSize', function() {
      var node = new DivSugar.Node();
      node.setSize(10, 20);
      strictEqual(node.getWidth(), 10);
      strictEqual(node.getHeight(), 20);
  
      ok(node.setSize(1, 1).setSize(1, 1));
    });
  
    test('setPosition', function() {
      var vec = new DivSugar.Vector(40, 50, 60);
      var node = new DivSugar.Node();
  
      node.setPosition(10, 20, 30);
      strictEqual(node.getPositionX(), 10);
      strictEqual(node.getPositionY(), 20);
      strictEqual(node.getPositionZ(), 30);
  
      node.setPosition(vec);
      strictEqual(node.getPositionX(), 40);
      strictEqual(node.getPositionY(), 50);
      strictEqual(node.getPositionZ(), 60);
  
      raises(function() {
        node.setPosition(1, 2);
      }, function(e) {
        strictEqual(e, 'DivSugar: Invalid number of arguments');
        return true;
      });
  
      ok(node.setPosition(0, 0, 0).setPosition(vec).setPosition(1, 1, 1));
    });
  
    test('setTransform', function() {
      var mat1 = new DivSugar.Matrix(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
      var mat2 = new DivSugar.Matrix();
      var node = new DivSugar.Node();
      node.setTransform(mat1);
      node.getTransform(mat2);
      deepEqual(mat2, mat1);
  
      ok(node.setTransform(mat1).setTransform(mat1));
    });
  
    test('setVisible', function() {
      var node = new DivSugar.Node();
      node.setVisible(false);
      strictEqual(node.getVisible(), false);
  
      ok(node.setVisible(true).setVisible(true));
    });
  
    test('setBackface', function() {
      var node = new DivSugar.Node();
      node.setBackface(false);
      strictEqual(node.getBackface(), false);
  
      ok(node.setBackface(true).setBackface(true));
    });
  
    test('setClip', function() {
      var node = new DivSugar.Node();
      node.setClip(true);
      strictEqual(node.getClip(), true);
  
      ok(node.setClip(true).setClip(true));
    });
  
    test('setOpacity', function() {
      var node = new DivSugar.Node();
      node.setOpacity(0.5);
      strictEqual(node.getOpacity(), 0.5);
  
      ok(node.setOpacity(0).setOpacity(0));
    });
  
    test('setImage', function() {
      var node = new DivSugar.Node();
  
      node.setImage('../examples/assets/coin.png');
      strictEqual(node.getImage(), '../examples/assets/coin.png');
  
      node.setImage('../examples/assets/coin.png', function(width, height) {
        start();
        strictEqual(width, 400);
        strictEqual(height, 200);
      });
      stop();
  
      ok(node.setImage(null).setImage(null));
    });
  
    test('setImageClip', function() {
      var node = new DivSugar.Node();
  
      node.setImageClip(0.1, 0.2, 0.3, 0.4);
      strictEqual(node.getImageClipU1(), 0.1);
      strictEqual(node.getImageClipV1(), 0.2);
      strictEqual(node.getImageClipU2(), 0.3);
      strictEqual(node.getImageClipV2(), 0.4);
  
      node.setImageClip(-1, -2, -3, -4);
      strictEqual(node.getImageClipU1(), 0);
      strictEqual(node.getImageClipV1(), 0);
      strictEqual(node.getImageClipU2(), 0);
      strictEqual(node.getImageClipV2(), 0);
  
      node.setImageClip(2, 3, 4, 5);
      strictEqual(node.getImageClipU1(), 1);
      strictEqual(node.getImageClipV1(), 1);
      strictEqual(node.getImageClipU2(), 1);
      strictEqual(node.getImageClipV2(), 1);
  
      ok(node.setImageClip(0, 0, 0, 0).setImageClip(0, 0, 0, 0));
    });
  
    test('translate', function() {
      var mat1 = new DivSugar.Matrix();
      var mat2 = new DivSugar.Matrix();
      var node = new DivSugar.Node();
      node.setTransform(mat1);
      node.translate(10, 20, 30);
      mat1.translate(10, 20, 30);
      node.getTransform(mat2);
      deepEqual(mat2, mat1);
  
      raises(function() {
        node.translate(1, 2);
      }, function(e) {
        strictEqual(e, 'DivSugar: Invalid number of arguments');
        return true;
      });
  
      ok(node.translate(0, 0, 0).translate(0, 0, 0));
    });
  
    test('rotate', function() {
      var mat1 = new DivSugar.Matrix();
      var mat2 = new DivSugar.Matrix();
      var node = new DivSugar.Node();
      node.setTransform(mat1);
      node.rotate(10, 20, 30);
      mat1.rotate(10, 20, 30);
      node.getTransform(mat2);
      nearlyEqual(mat2, mat1);
  
      raises(function() {
        node.rotate(90, 90);
      }, function(e) {
        strictEqual(e, 'DivSugar: Invalid number of arguments');
        return true;
      });
  
      ok(node.rotate(0, 0, 0).rotate(0, 0, 0));
    });
  
    test('rotateAround', function() {
      var vec = new DivSugar.Vector();
      var mat1 = new DivSugar.Matrix();
      var mat2 = new DivSugar.Matrix();
      var node = new DivSugar.Node();
      vec.set(1, 1, 1).normalize();
      mat1.set(0, 0, -1, -1, 0, 0, 0, 1, 0, 100, 200, 300);
      node.setTransform(mat1);
      node.rotateAround(vec, 90);
      mat1.rotateAround(vec, 90);
      node.getTransform(mat2);
      nearlyEqual(mat2, mat1);
  
      ok(node.rotateAround(vec, 0).rotateAround(vec, 0));
    });
  
    test('scale', function() {
      var mat1 = new DivSugar.Matrix();
      var mat2 = new DivSugar.Matrix();
      var node = new DivSugar.Node();
      node.setTransform(mat1);
      node.scale(10, 20, 30);
      mat1.scale(10, 20, 30);
      node.getTransform(mat2);
      deepEqual(mat2, mat1);
  
      raises(function() {
        node.scale(2, 3);
      }, function(e) {
        strictEqual(e, 'DivSugar: Invalid number of arguments');
        return true;
      });
  
      ok(node.scale(1, 1, 1).scale(1, 1, 1));
    });
  
    test('playAnimation', function() {
      var callCount = 0;
      var mat = new DivSugar.Matrix();
      var func = function() { callCount++; };
      var anim1 = [['call', func, func]];
      var anim2 = [
        ['to', {
            size: [100, 200],
            position: [1, 2, 3],
            transform: new DivSugar.Matrix().rotate(0, 90, 0),
            visible: false,
            backface: false,
            clip: true,
            opacity: 0.5,
            image: '../examples/assets/coin.png',
            imageClip: [0.1, 0.2, 0.3, 0.4],
            translate: [10, 20, 30],
            rotate: [10, 20, 30],
            scale: [1, 2, 3]
          }, 10, DivSugar.Ease.quadInOut ],
        ['play', anim1, anim1],
        ['wait', 5],
        ['repeat', 2],
        ['wait', 5]
      ];
      var anim3 = [['to', { dummy: 0 }, 10]];
      var anim4 = [['dummy']];
      var node = new DivSugar.Node();
      var task = node.playAnimation(anim2);
  
      strictEqual(callCount, 0);
      strictEqual(task.animation, anim2);
      strictEqual(task.getParent(), DivSugar.rootTask);
      strictEqual(node.getWidth(), 0);
      strictEqual(node.getHeight(), 0);
      strictEqual(node.getVisible(), true);
      strictEqual(node.getBackface(), true);
      strictEqual(node.getClip(), false);
      strictEqual(node.getOpacity(), 1);
      strictEqual(node.getImage(), null);
      strictEqual(node.getImageClipU1(), 0);
      strictEqual(node.getImageClipV1(), 0);
      strictEqual(node.getImageClipU2(), 1);
      strictEqual(node.getImageClipV2(), 1);
      node.getTransform(mat);
      deepEqual(mat, DivSugar.Matrix.UNIT);
  
      DivSugar.rootTask.update(10);
      strictEqual(callCount, 0);
      strictEqual(task.getParent(), DivSugar.rootTask);
      strictEqual(node.getWidth(), 100);
      strictEqual(node.getHeight(), 200);
      strictEqual(node.getVisible(), false);
      strictEqual(node.getBackface(), false);
      strictEqual(node.getClip(), true);
      strictEqual(node.getOpacity(), 0.5);
      strictEqual(node.getImage(), '../examples/assets/coin.png');
      strictEqual(node.getImageClipU1(), 0.1);
      strictEqual(node.getImageClipV1(), 0.2);
      strictEqual(node.getImageClipU2(), 0.3);
      strictEqual(node.getImageClipV2(), 0.4);
      node.getTransform(mat);
      deepEqual(mat, new DivSugar.Matrix().rotate(0, 90, 0).translate(10, 20, 30).rotate(10, 20, 30).scale(1, 2, 3));
  
      DivSugar.rootTask.update(1);
      strictEqual(callCount, 0);
      strictEqual(task.getParent(), DivSugar.rootTask);
  
      DivSugar.rootTask.update(1);
      strictEqual(callCount, 4);
      strictEqual(task.getParent(), DivSugar.rootTask);
  
      DivSugar.rootTask.update(38);
      strictEqual(callCount, 4);
      strictEqual(task.getParent(), DivSugar.rootTask);
  
      DivSugar.rootTask.update(1);
      strictEqual(callCount, 12);
      strictEqual(task.getParent(), null);
  
      raises(function() {
        task = node.playAnimation(anim3);
        DivSugar.rootTask.update(1);
      }, function(e) {
        strictEqual(e, "DivSugar: Unknown animation parameter 'dummy'");
        return true;
      });
      task.destroy();
  
      raises(function() {
        task = node.playAnimation(anim4);
        DivSugar.rootTask.update(1);
      }, function(e) {
        strictEqual(e, "DivSugar: Unknown animation command 'dummy'");
        return true;
      });
      task.destroy();
    });
  
    test('clearAnimations', function() {
      var anim = [['wait', 1], ['repeat']];
      var node = new DivSugar.Node();
      var task1 = node.playAnimation(anim);
      var task2 = node.playAnimation(anim);
      var task3 = node.playAnimation(anim);
  
      DivSugar.rootTask.update(10);
      strictEqual(task1.getParent(), DivSugar.rootTask);
      strictEqual(task2.getParent(), DivSugar.rootTask);
      strictEqual(task3.getParent(), DivSugar.rootTask);
  
      node.clearAnimations();
      strictEqual(task1.getParent(), null);
      strictEqual(task2.getParent(), null);
      strictEqual(task3.getParent(), null);
  
      ok(node.clearAnimations().clearAnimations());
    });
  
    test('getWorldPosition', function() {
      var vec = new DivSugar.Vector();
      var scn = new DivSugar.Scene();
      var node1 = new DivSugar.Node().setPosition(10, 10, 10).rotate(0, 180, 0);
      var node2 = new DivSugar.Node().setPosition(100, 100, 100).rotate(0, 180, 0);
      var node3 = new DivSugar.Node().setPosition(1000, 1000, 1000);
  
      node1.getWorldPosition(vec);
      nearlyEqual(vec, new DivSugar.Vector(10, 10, 10));
  
      scn.append(node1);
      node1.getWorldPosition(vec);
      nearlyEqual(vec, new DivSugar.Vector(10, 10, 10));
  
      node1.append(node2);
      node2.getWorldPosition(vec);
      nearlyEqual(vec, new DivSugar.Vector(-90, 110, -90));
  
      node2.append(node3);
      node3.getWorldPosition(vec);
      nearlyEqual(vec, new DivSugar.Vector(910, 1110, 910));
  
      ok(node1.getWorldPosition(vec).getWorldPosition(vec));
    });
  
    test('getWorldTransform', function() {
      var mat = new DivSugar.Matrix();
      var scn = new DivSugar.Scene();
      var node1 = new DivSugar.Node().setPosition(10, 10, 10).rotate(0, 180, 0);
      var node2 = new DivSugar.Node().setPosition(100, 100, 100).rotate(0, 180, 0);
      var node3 = new DivSugar.Node().setPosition(1000, 1000, 1000);
  
      node1.getWorldTransform(mat);
      nearlyEqual(mat, new DivSugar.Matrix().translate(10, 10, 10).rotate(0, 180, 0));
  
      scn.append(node1);
      node1.getWorldTransform(mat);
      nearlyEqual(mat, new DivSugar.Matrix().translate(10, 10, 10).rotate(0, 180, 0));
  
      node1.append(node2);
      node2.getWorldTransform(mat);
      nearlyEqual(mat, new DivSugar.Matrix().translate(-90, 110, -90));
  
      node2.append(node3);
      node3.getWorldTransform(mat);
      nearlyEqual(mat, new DivSugar.Matrix().translate(910, 1110, 910));
  
      ok(node1.getWorldTransform(mat).getWorldTransform(mat));
    });
  })();