lint the tests (#23052)

test/benchmark/benchmark.js

@@ -1,79 +1,103 @@
-var BenchClass = function() {
-  this.suites = [];
-  this.THREE = window.THREE ;
-  window.THREE = undefined;
-  Benchmark.options.maxTime = 1.0;
-  return this;
-}
-
-BenchClass.prototype.isTHREELoaded = function() {
-  return _.isObject(this.THREE);
-}
-
-BenchClass.prototype.newSuite = function(name) {
-  var s = new Benchmark.Suite(name);
-  this.suites.push(s);
-  return s;
-}
-
-BenchClass.prototype.display = function() {
-  for (x of this.suites) {
-    var s = new SuiteUI(x);
-    s.render();
-  }
-}
-
-BenchClass.prototype.warning = function(message) {
-  console.error(message);
-}
-
-var SuiteUI = function(suite) {
-  this.suite = suite;
-  this.isRunning = false;
-  return this;
-}
-
-SuiteUI.prototype.render = function() {
-  var n = document.importNode(this.suiteTemplate, true);
-  this.elem = n.querySelector("article");
-  this.results = n.querySelector(".results");
-  this.title = n.querySelector("h2");
-  this.runButton = n.querySelector("h3");
-
-  this.title.innerText = this.suite.name;
-  this.runButton.onclick = this.run.bind(this);
-
-  this.section.appendChild(n);
-}
-
-SuiteUI.prototype.run = function() {
-  this.runButton.click = _.noop;
-  this.runButton.innerText = "Running..."
-  this.suite.on("complete", this.complete.bind(this));
-  this.suite.run({
-    async: true
-  });
-}
-
-SuiteUI.prototype.complete = function() {
-  this.runButton.style.display = "none";
-  this.results.style.display = "block";
-  var f = _.orderBy(this.suite, ["hz"], ["desc"]);
-  for (var i = 0; i < f.length; i++) {
-    var x = f[i];
-    var n = document.importNode(this.suiteTestTemplate, true);
-    n.querySelector(".name").innerText = x.name;
-    n.querySelector(".ops").innerText = x.hz.toFixed();
-    n.querySelector(".desv").innerText = x.stats.rme.toFixed(2);
-    this.results.appendChild(n);
-  }
-}
+var BenchClass = function () {
+
+	this.suites = [];
+	this.THREE = window.THREE;
+	window.THREE = undefined;
+	Benchmark.options.maxTime = 1.0;
+	return this;
+
+};
+
+BenchClass.prototype.isTHREELoaded = function () {
+
+	return _.isObject( this.THREE );
+
+};
+
+BenchClass.prototype.newSuite = function ( name ) {
+
+	var s = new Benchmark.Suite( name );
+	this.suites.push( s );
+	return s;
+
+};
+
+BenchClass.prototype.display = function () {
+
+	for ( x of this.suites ) {
+
+		var s = new SuiteUI( x );
+		s.render();
+
+	}
+
+};
+
+BenchClass.prototype.warning = function ( message ) {
+
+	console.error( message );
+
+};
+
+var SuiteUI = function ( suite ) {
+
+	this.suite = suite;
+	this.isRunning = false;
+	return this;
+
+};
+
+SuiteUI.prototype.render = function () {
+
+	var n = document.importNode( this.suiteTemplate, true );
+	this.elem = n.querySelector( 'article' );
+	this.results = n.querySelector( '.results' );
+	this.title = n.querySelector( 'h2' );
+	this.runButton = n.querySelector( 'h3' );
+
+	this.title.innerText = this.suite.name;
+	this.runButton.onclick = this.run.bind( this );
+
+	this.section.appendChild( n );
+
+};
+
+SuiteUI.prototype.run = function () {
+
+	this.runButton.click = _.noop;
+	this.runButton.innerText = 'Running...';
+	this.suite.on( 'complete', this.complete.bind( this ) );
+	this.suite.run( {
+		async: true
+	} );
+
+};
+
+SuiteUI.prototype.complete = function () {
+
+	this.runButton.style.display = 'none';
+	this.results.style.display = 'block';
+	var f = _.orderBy( this.suite, [ 'hz' ], [ 'desc' ] );
+	for ( var i = 0; i < f.length; i ++ ) {
+
+		var x = f[ i ];
+		var n = document.importNode( this.suiteTestTemplate, true );
+		n.querySelector( '.name' ).innerText = x.name;
+		n.querySelector( '.ops' ).innerText = x.hz.toFixed();
+		n.querySelector( '.desv' ).innerText = x.stats.rme.toFixed( 2 );
+		this.results.appendChild( n );
+
+	}
+
+};
 
 var Bench = new BenchClass();
-window.addEventListener('load', function() {
-  SuiteUI.prototype.suiteTemplate = document.querySelector("#suite").content;
-  SuiteUI.prototype.suiteTestTemplate = document.querySelector("#suite-test").content;
-  SuiteUI.prototype.section = document.querySelector("section");
+window.addEventListener( 'load', function () {
+
+	SuiteUI.prototype.suiteTemplate = document.querySelector( '#suite' ).content;
+	SuiteUI.prototype.suiteTestTemplate = document.querySelector( '#suite-test' ).content;
+	SuiteUI.prototype.section = document.querySelector( 'section' );
+
+	Bench.display();
 
-  Bench.display();
-})
+} );

test/benchmark/core/Float32Array.js

@@ -1,82 +1,102 @@
-(function() {
-
-  var input = new Float32Array(10000 * 3);
-  var output = new Float32Array(10000 * 3);
-
-  for (var j = 0, jl = input.length; j < jl; j++) {
-    input[j] = j;
-  }
-
-  var inputVectors = [];
-  var outputVectors = [];
-
-  for (var j = 0, jl = input.length / 3; j < jl; j++) {
-    inputVectors.push(new THREE.Vector3(j * 3, j * 3 + 1, j * 3 + 2));
-    outputVectors.push(new THREE.Vector3());
-  }
-
-  var s = Bench.newSuite("Float 32 Arrays");
-
-  s.add('Float32Array-Float32Array', function() {
-    var value3 = new Float32Array(3);
-    for (var i = 0, il = input.length / 3; i < il; i += 3) {
-      value3[0] = input[i + 0];
-      value3[1] = input[i + 1];
-      value3[2] = input[i + 2];
-      value3[0] *= 1.01;
-      value3[1] *= 1.03;
-      value3[2] *= 0.98;
-      output[i + 0] = value3[0];
-      output[i + 1] = value3[1];
-      output[i + 2] = value3[2];
-    }
-  });
-
-  s.add('Float32Array-Array', function() {
-    var value2 = [0, 0, 0];
-    for (var i = 0, il = input.length / 3; i < il; i += 3) {
-      value2[0] = input[i + 0];
-      value2[1] = input[i + 1];
-      value2[2] = input[i + 2];
-      value2[0] *= 1.01;
-      value2[1] *= 1.03;
-      value2[2] *= 0.98;
-      output[i + 0] = value2[0];
-      output[i + 1] = value2[1];
-      output[i + 2] = value2[2];
-    }
-  });
-
-  s.add('Float32Array-Literal', function() {
-    var x,
-      y,
-      z;
-    for (var i = 0, il = input.length / 3; i < il; i += 3) {
-      x = input[i + 0];
-      y = input[i + 1];
-      z = input[i + 2];
-      x *= 1.01;
-      y *= 1.03;
-      z *= 0.98;
-      output[i + 0] = x;
-      output[i + 1] = y;
-      output[i + 2] = z;
-    }
-  });
-
-  s.add('Float32Array-Vector3', function() {
-    var value = new THREE.Vector3();
-    for (var i = 0, il = input.length / 3; i < il; i += 3) {
-      value.x = input[i + 0];
-      value.y = input[i + 1];
-      value.z = input[i + 2];
-      value.x *= 1.01;
-      value.y *= 1.03;
-      value.z *= 0.98;
-      output[i + 0] = value.x;
-      output[i + 1] = value.y;
-      output[i + 2] = value.z;
-    }
-  });
-
-})();
+( function () {
+
+	var input = new Float32Array( 10000 * 3 );
+	var output = new Float32Array( 10000 * 3 );
+
+	for ( var j = 0, jl = input.length; j < jl; j ++ ) {
+
+		input[ j ] = j;
+
+	}
+
+	var inputVectors = [];
+	var outputVectors = [];
+
+	for ( var j = 0, jl = input.length / 3; j < jl; j ++ ) {
+
+		inputVectors.push( new THREE.Vector3( j * 3, j * 3 + 1, j * 3 + 2 ) );
+		outputVectors.push( new THREE.Vector3() );
+
+	}
+
+	var s = Bench.newSuite( 'Float 32 Arrays' );
+
+	s.add( 'Float32Array-Float32Array', function () {
+
+		var value3 = new Float32Array( 3 );
+		for ( var i = 0, il = input.length / 3; i < il; i += 3 ) {
+
+			value3[ 0 ] = input[ i + 0 ];
+			value3[ 1 ] = input[ i + 1 ];
+			value3[ 2 ] = input[ i + 2 ];
+			value3[ 0 ] *= 1.01;
+			value3[ 1 ] *= 1.03;
+			value3[ 2 ] *= 0.98;
+			output[ i + 0 ] = value3[ 0 ];
+			output[ i + 1 ] = value3[ 1 ];
+			output[ i + 2 ] = value3[ 2 ];
+
+		}
+
+	} );
+
+	s.add( 'Float32Array-Array', function () {
+
+		var value2 = [ 0, 0, 0 ];
+		for ( var i = 0, il = input.length / 3; i < il; i += 3 ) {
+
+			value2[ 0 ] = input[ i + 0 ];
+			value2[ 1 ] = input[ i + 1 ];
+			value2[ 2 ] = input[ i + 2 ];
+			value2[ 0 ] *= 1.01;
+			value2[ 1 ] *= 1.03;
+			value2[ 2 ] *= 0.98;
+			output[ i + 0 ] = value2[ 0 ];
+			output[ i + 1 ] = value2[ 1 ];
+			output[ i + 2 ] = value2[ 2 ];
+
+		}
+
+	} );
+
+	s.add( 'Float32Array-Literal', function () {
+
+		var x,
+			y,
+			z;
+		for ( var i = 0, il = input.length / 3; i < il; i += 3 ) {
+
+			x = input[ i + 0 ];
+			y = input[ i + 1 ];
+			z = input[ i + 2 ];
+			x *= 1.01;
+			y *= 1.03;
+			z *= 0.98;
+			output[ i + 0 ] = x;
+			output[ i + 1 ] = y;
+			output[ i + 2 ] = z;
+
+		}
+
+	} );
+
+	s.add( 'Float32Array-Vector3', function () {
+
+		var value = new THREE.Vector3();
+		for ( var i = 0, il = input.length / 3; i < il; i += 3 ) {
+
+			value.x = input[ i + 0 ];
+			value.y = input[ i + 1 ];
+			value.z = input[ i + 2 ];
+			value.x *= 1.01;
+			value.y *= 1.03;
+			value.z *= 0.98;
+			output[ i + 0 ] = value.x;
+			output[ i + 1 ] = value.y;
+			output[ i + 2 ] = value.z;
+
+		}
+
+	} );
+
+} )();

test/benchmark/core/TriangleClosestPoint.js

@@ -1,61 +1,80 @@
-(function() {
-
-  THREE = Bench.THREE;
-
-  // these vertices and triangles are those of a unit icosahedron centered at the origin
-  var phi = 1.618;
-  var verts = [
-    [phi, 1, 0], [-phi, 1, 0], [phi, -1, 0], [-phi, -1, 0],
-    [1, 0, phi], [1, 0, -phi], [-1, 0, phi], [-1, 0, -phi],
-    [0, phi, 1], [0, -phi, 1], [0, phi, -1], [0, -phi, -1],
-  ];
-  var createVertex = function(c) {
-    return new THREE.Vector3(c[0], c[1], c[2]);
-  };
-  var createTriangle = function(i0, i1, i2) {
-    return new THREE.Triangle(createVertex(verts[i0]), createVertex(verts[i1]), createVertex(verts[i2]));
-  };
-  var triangles = [
-    createTriangle(0, 8, 4),
-    createTriangle(0, 5, 10),
-    createTriangle(2, 4, 9),
-    createTriangle(2, 11, 5),
-    createTriangle(1, 6, 8),
-    createTriangle(1, 10, 7),
-    createTriangle(3, 9, 6),
-    createTriangle(3, 7, 11),
-    createTriangle(0, 10, 8),
-    createTriangle(1, 8, 10),
-    createTriangle(2, 9, 11),
-    createTriangle(3, 9, 11),
-    createTriangle(4, 2, 0),
-    createTriangle(5, 0, 2),
-    createTriangle(6, 1, 3),
-    createTriangle(7, 3, 1),
-    createTriangle(8, 6, 4),
-    createTriangle(9, 4, 6),
-    createTriangle(10, 5, 7),
-    createTriangle(11, 7, 5),
-  ];
-  // test a variety of points all in and around the icosahedron
-  var testPoints = [];
-  for (var x = -2; x <= 2; x += 0.5) {
-    for (var y = -2; y <= 2; y += 0.5) {
-      for (var z = -2; z <= 2; z += 0.5) {
-        testPoints.push(new THREE.Vector3(x, y, z));
-      }
-    }
-  }
-
-  var s = Bench.newSuite("Clamping point into triangles");
-
-  s.add('9^3 points, 20 triangles', function() {
-    var target = new THREE.Vector3();
-    for (var tidx = 0; tidx < triangles.length; tidx++) {
-      var triangle = triangles[tidx];
-      for (var pidx = 0; pidx < testPoints.length; pidx++) {
-        triangle.closestPointToPoint(testPoints[pidx], target);
-      }
-    }
-  });
-})();
+( function () {
+
+	THREE = Bench.THREE;
+
+	// these vertices and triangles are those of a unit icosahedron centered at the origin
+	var phi = 1.618;
+	var verts = [
+		[ phi, 1, 0 ], [ - phi, 1, 0 ], [ phi, - 1, 0 ], [ - phi, - 1, 0 ],
+		[ 1, 0, phi ], [ 1, 0, - phi ], [ - 1, 0, phi ], [ - 1, 0, - phi ],
+		[ 0, phi, 1 ], [ 0, - phi, 1 ], [ 0, phi, - 1 ], [ 0, - phi, - 1 ],
+	];
+	var createVertex = function ( c ) {
+
+		return new THREE.Vector3( c[ 0 ], c[ 1 ], c[ 2 ] );
+
+	};
+
+	var createTriangle = function ( i0, i1, i2 ) {
+
+		return new THREE.Triangle( createVertex( verts[ i0 ] ), createVertex( verts[ i1 ] ), createVertex( verts[ i2 ] ) );
+
+	};
+
+	var triangles = [
+		createTriangle( 0, 8, 4 ),
+		createTriangle( 0, 5, 10 ),
+		createTriangle( 2, 4, 9 ),
+		createTriangle( 2, 11, 5 ),
+		createTriangle( 1, 6, 8 ),
+		createTriangle( 1, 10, 7 ),
+		createTriangle( 3, 9, 6 ),
+		createTriangle( 3, 7, 11 ),
+		createTriangle( 0, 10, 8 ),
+		createTriangle( 1, 8, 10 ),
+		createTriangle( 2, 9, 11 ),
+		createTriangle( 3, 9, 11 ),
+		createTriangle( 4, 2, 0 ),
+		createTriangle( 5, 0, 2 ),
+		createTriangle( 6, 1, 3 ),
+		createTriangle( 7, 3, 1 ),
+		createTriangle( 8, 6, 4 ),
+		createTriangle( 9, 4, 6 ),
+		createTriangle( 10, 5, 7 ),
+		createTriangle( 11, 7, 5 ),
+	];
+	// test a variety of points all in and around the icosahedron
+	var testPoints = [];
+	for ( var x = - 2; x <= 2; x += 0.5 ) {
+
+		for ( var y = - 2; y <= 2; y += 0.5 ) {
+
+			for ( var z = - 2; z <= 2; z += 0.5 ) {
+
+				testPoints.push( new THREE.Vector3( x, y, z ) );
+
+			}
+
+		}
+
+	}
+
+	var s = Bench.newSuite( 'Clamping point into triangles' );
+
+	s.add( '9^3 points, 20 triangles', function () {
+
+		var target = new THREE.Vector3();
+		for ( var tidx = 0; tidx < triangles.length; tidx ++ ) {
+
+			var triangle = triangles[ tidx ];
+			for ( var pidx = 0; pidx < testPoints.length; pidx ++ ) {
+
+				triangle.closestPointToPoint( testPoints[ pidx ], target );
+
+			}
+
+		}
+
+	} );
+
+} )();

test/benchmark/core/UpdateMatrixWorld.js

@@ -1,48 +1,69 @@
-(function() {
-
-  THREE = Bench.THREE;
-
-  var position = new THREE.Vector3(1, 1, 1);
-  var scale = new THREE.Vector3(2, 1, 0.5);
-  var rotation = new THREE.Quaternion();
-  rotation.setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 8);
-  var createLocallyOffsetChild = function() {
-    var child = new THREE.Object3D();
-    child.position.copy(position);
-    child.scale.copy(scale);
-    child.rotation.copy(rotation);
-    return child;
-  };
-
-  var generateSceneGraph = function(root, depth, breadth, initObject) {
-    if (depth > 0) {
-      for (var i = 0; i < breadth; i++) {
-        var child = initObject();
-        root.add(child);
-        generateSceneGraph(child, depth - 1, breadth, initObject);
-      }
-    }
-    return root;
-  };
-
-  var nodeCount = function(root) {
-    return root.children.reduce(function(acc, x) { return acc + nodeCount(x); }, 1);
-  };
-
-  var rootA = generateSceneGraph(new THREE.Object3D(), 100, 1, createLocallyOffsetChild);
-  var rootB = generateSceneGraph(new THREE.Object3D(), 3, 10, createLocallyOffsetChild);
-  var rootC = generateSceneGraph(new THREE.Object3D(), 9, 3, createLocallyOffsetChild);
-
-  var s = Bench.newSuite("Update world transforms");
-
-  s.add('Update graph depth=100, breadth=1 (' + nodeCount(rootA) + ' nodes)', function() {
-    rootA.updateMatrixWorld(true);
-  });
-  s.add('Update graph depth=3, breadth=10 (' + nodeCount(rootB) + ' nodes)', function() {
-    rootB.updateMatrixWorld(true);
-  });
-  s.add('Update graph depth=9, breadth=3 (' + nodeCount(rootC) + ' nodes)', function() {
-    rootC.updateMatrixWorld(true);
-  });
-
-})();
+( function () {
+
+	THREE = Bench.THREE;
+
+	var position = new THREE.Vector3( 1, 1, 1 );
+	var scale = new THREE.Vector3( 2, 1, 0.5 );
+	var rotation = new THREE.Quaternion();
+	rotation.setFromAxisAngle( new THREE.Vector3( 0, 1, 0 ), Math.PI / 8 );
+	var createLocallyOffsetChild = function () {
+
+		var child = new THREE.Object3D();
+		child.position.copy( position );
+		child.scale.copy( scale );
+		child.rotation.copy( rotation );
+		return child;
+
+	};
+
+	var generateSceneGraph = function ( root, depth, breadth, initObject ) {
+
+		if ( depth > 0 ) {
+
+			for ( var i = 0; i < breadth; i ++ ) {
+
+				var child = initObject();
+				root.add( child );
+				generateSceneGraph( child, depth - 1, breadth, initObject );
+
+			}
+
+		}
+
+		return root;
+
+	};
+
+	var nodeCount = function ( root ) {
+
+		return root.children.reduce( function ( acc, x ) {
+
+			return acc + nodeCount( x );
+
+		}, 1 );
+
+	};
+
+	var rootA = generateSceneGraph( new THREE.Object3D(), 100, 1, createLocallyOffsetChild );
+	var rootB = generateSceneGraph( new THREE.Object3D(), 3, 10, createLocallyOffsetChild );
+	var rootC = generateSceneGraph( new THREE.Object3D(), 9, 3, createLocallyOffsetChild );
+
+	var s = Bench.newSuite( 'Update world transforms' );
+
+	s.add( 'Update graph depth=100, breadth=1 (' + nodeCount( rootA ) + ' nodes)', function () {
+
+		rootA.updateMatrixWorld( true );
+
+	} );
+	s.add( 'Update graph depth=3, breadth=10 (' + nodeCount( rootB ) + ' nodes)', function () {
+
+		rootB.updateMatrixWorld( true );
+
+	} );
+	s.add( 'Update graph depth=9, breadth=3 (' + nodeCount( rootC ) + ' nodes)', function () {
+
+		rootC.updateMatrixWorld( true );
+
+	} );
+
+} )();

test/benchmark/core/Vector3Components.js

@@ -1,110 +1,146 @@
-(function() {
-
-  var s = Bench.newSuite("Vector 3 Components");
-
-  THREE = {};
-
-  THREE.Vector3 = function(x, y, z) {
-    this.x = x || 0;
-    this.y = y || 0;
-    this.z = z || 0;
-  };
-
-  THREE.Vector3.prototype = {
-    constructor: THREE.Vector3,
-    setComponent: function(index, value) {
-      this[THREE.Vector3.__indexToName[index]] = value;
-    },
-
-    getComponent: function(index) {
-      return this[THREE.Vector3.__indexToName[index]];
-    },
-
-    setComponent2: function(index, value) {
-      switch (index) {
-        case 0:
-          this.x = value;
-          break;
-        case 1:
-          this.y = value;
-          break;
-        case 2:
-          this.z = value;
-          break;
-        default:
-          throw new Error("index is out of range: " + index);
-      }
-    },
-
-    getComponent2: function(index) {
-      switch (index) {
-        case 0:
-          return this.x;
-        case 1:
-          return this.y;
-        case 2:
-          return this.z;
-        default:
-          throw new Error("index is out of range: " + index);
-      }
-    },
-
-
-    getComponent3: function(index) {
-      if (index === 0) return this.x;
-      if (index === 1) return this.y;
-      if (index === 2) return this.z;
-      throw new Error("index is out of range: " + index);
-    },
-
-    getComponent4: function(index) {
-      if (index === 0) return this.x;else if (index === 1) return this.y;else if (index === 2) return this.z;
-      else
-        throw new Error("index is out of range: " + index);
-    }
-  };
-
-
-  THREE.Vector3.__indexToName = {
-    0: 'x',
-    1: 'y',
-    2: 'z'
-  };
-
-  var a = [];
-  for (var i = 0; i < 100000; i++) {
-    a[i] = new THREE.Vector3(i * 0.01, i * 2, i * -1.3);
-  }
-
-
-
-
-  s.add('IndexToName', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      result += a[i].getComponent(i % 3);
-    }
-  });
-
-  s.add('SwitchStatement', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      result += a[i].getComponent2(i % 3);
-    }
-  });
-
-  s.add('IfAndReturnSeries', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      result += a[i].getComponent3(i % 3);
-    }
-  });
-
-  s.add('IfReturnElseSeries', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      result += a[i].getComponent4(i % 3);
-    }
-  });
-
-})();
+( function () {
+
+	var s = Bench.newSuite( 'Vector 3 Components' );
+
+	THREE = {};
+
+	THREE.Vector3 = function ( x, y, z ) {
+
+		this.x = x || 0;
+		this.y = y || 0;
+		this.z = z || 0;
+
+	};
+
+	THREE.Vector3.prototype = {
+		constructor: THREE.Vector3,
+		setComponent: function ( index, value ) {
+
+			this[ THREE.Vector3.__indexToName[ index ] ] = value;
+
+		},
+
+		getComponent: function ( index ) {
+
+			return this[ THREE.Vector3.__indexToName[ index ] ];
+
+		},
+
+		setComponent2: function ( index, value ) {
+
+			switch ( index ) {
+
+				case 0:
+					this.x = value;
+					break;
+				case 1:
+					this.y = value;
+					break;
+				case 2:
+					this.z = value;
+					break;
+				default:
+					throw new Error( 'index is out of range: ' + index );
+
+			}
+
+		},
+
+		getComponent2: function ( index ) {
+
+			switch ( index ) {
+
+				case 0:
+					return this.x;
+				case 1:
+					return this.y;
+				case 2:
+					return this.z;
+				default:
+					throw new Error( 'index is out of range: ' + index );
+
+			}
+
+		},
+
+
+		getComponent3: function ( index ) {
+
+			if ( index === 0 ) return this.x;
+			if ( index === 1 ) return this.y;
+			if ( index === 2 ) return this.z;
+			throw new Error( 'index is out of range: ' + index );
+
+		},
+
+		getComponent4: function ( index ) {
+
+			if ( index === 0 ) return this.x; else if ( index === 1 ) return this.y; else if ( index === 2 ) return this.z;
+			else
+				throw new Error( 'index is out of range: ' + index );
+
+		}
+	};
+
+
+	THREE.Vector3.__indexToName = {
+		0: 'x',
+		1: 'y',
+		2: 'z'
+	};
+
+	var a = [];
+	for ( var i = 0; i < 100000; i ++ ) {
+
+		a[ i ] = new THREE.Vector3( i * 0.01, i * 2, i * - 1.3 );
+
+	}
+
+
+
+
+	s.add( 'IndexToName', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			result += a[ i ].getComponent( i % 3 );
+
+		}
+
+	} );
+
+	s.add( 'SwitchStatement', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			result += a[ i ].getComponent2( i % 3 );
+
+		}
+
+	} );
+
+	s.add( 'IfAndReturnSeries', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			result += a[ i ].getComponent3( i % 3 );
+
+		}
+
+	} );
+
+	s.add( 'IfReturnElseSeries', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			result += a[ i ].getComponent4( i % 3 );
+
+		}
+
+	} );
+
+} )();

test/benchmark/core/Vector3Length.js

@@ -1,59 +1,79 @@
-(function() {
+( function () {
 
-  var THREE = {};
+	var THREE = {};
 
-  THREE.Vector3 = function(x, y, z) {
+	THREE.Vector3 = function ( x, y, z ) {
 
-    this.x = x || 0;
-    this.y = y || 0;
-    this.z = z || 0;
+		this.x = x || 0;
+		this.y = y || 0;
+		this.z = z || 0;
 
-  };
+	};
 
-  THREE.Vector3.prototype = {
-    constructor: THREE.Vector3,
-    lengthSq: function() {
-      return this.x * this.x + this.y * this.y + this.z * this.z;
-    },
+	THREE.Vector3.prototype = {
+		constructor: THREE.Vector3,
+		lengthSq: function () {
 
-    length: function() {
-      return Math.sqrt(this.lengthSq());
-    },
+			return this.x * this.x + this.y * this.y + this.z * this.z;
 
-    length2: function() {
-      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-    }
+		},
 
-  };
+		length: function () {
 
-  var a = [];
-  for (var i = 0; i < 100000; i++) {
-    a[i] = new THREE.Vector3(i * 0.01, i * 2, i * -1.3);
-  }
+			return Math.sqrt( this.lengthSq() );
 
+		},
 
-  var suite = Bench.newSuite("Vector 3 Length");
+		length2: function () {
 
-  suite.add('NoCallTest', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      var v = a[i];
-      result += Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
-    }
-  });
+			return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
 
-  suite.add('InlineCallTest', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      result += a[i].length2();
-    }
-  });
+		}
 
-  suite.add('FunctionCallTest', function() {
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      result += a[i].length();
-    }
-  });
+	};
 
-})();
+	var a = [];
+	for ( var i = 0; i < 100000; i ++ ) {
+
+		a[ i ] = new THREE.Vector3( i * 0.01, i * 2, i * - 1.3 );
+
+	}
+
+
+	var suite = Bench.newSuite( 'Vector 3 Length' );
+
+	suite.add( 'NoCallTest', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			var v = a[ i ];
+			result += Math.sqrt( v.x * v.x + v.y * v.y + v.z * v.z );
+
+		}
+
+	} );
+
+	suite.add( 'InlineCallTest', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			result += a[ i ].length2();
+
+		}
+
+	} );
+
+	suite.add( 'FunctionCallTest', function () {
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			result += a[ i ].length();
+
+		}
+
+	} );
+
+} )();

test/benchmark/core/Vector3Storage.js

@@ -1,113 +1,128 @@
-(function() {
+( function () {
 
-  THREE = {};
+	THREE = {};
 
-  THREE.Vector3 = function(x, y, z) {
+	THREE.Vector3 = function ( x, y, z ) {
 
-    this.x = x || 0;
-    this.y = y || 0;
-    this.z = z || 0;
+		this.x = x || 0;
+		this.y = y || 0;
+		this.z = z || 0;
 
-  };
+	};
 
-  THREE.Vector3.prototype = {
+	THREE.Vector3.prototype = {
 
-    constructor: THREE.Vector3,
+		constructor: THREE.Vector3,
 
-    length: function() {
+		length: function () {
 
-      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+			return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
 
-    }
+		}
 
-  };
+	};
 
-  THREE.Vector3X = function(x, y, z) {
+	THREE.Vector3X = function ( x, y, z ) {
 
-    var elements = this.elements = new Float32Array(3);
-    elements[0] = x || 0;
-    elements[1] = y || 1;
-    elements[2] = z || 2;
+		var elements = this.elements = new Float32Array( 3 );
+		elements[ 0 ] = x || 0;
+		elements[ 1 ] = y || 1;
+		elements[ 2 ] = z || 2;
 
-  };
+	};
 
-  THREE.Vector3X.prototype = {
+	THREE.Vector3X.prototype = {
 
-    constructor: THREE.Vector3X,
+		constructor: THREE.Vector3X,
 
-    length: function() {
+		length: function () {
 
-      return Math.sqrt(this.elements[0] * this.elements[0] + this.elements[1] * this.elements[1] + this.elements[2] * this.elements[2]);
+			return Math.sqrt( this.elements[ 0 ] * this.elements[ 0 ] + this.elements[ 1 ] * this.elements[ 1 ] + this.elements[ 2 ] * this.elements[ 2 ] );
 
-    }
+		}
 
-  };
+	};
 
 
-  THREE.Vector3Y = function(x, y, z) {
+	THREE.Vector3Y = function ( x, y, z ) {
 
-    this.elements = [x || 0, y || 1, z || 2];
+		this.elements = [ x || 0, y || 1, z || 2 ];
 
-  };
+	};
 
-  THREE.Vector3Y.prototype = {
+	THREE.Vector3Y.prototype = {
 
-    constructor: THREE.Vector3Y,
+		constructor: THREE.Vector3Y,
 
-    length: function() {
+		length: function () {
 
-      return Math.sqrt(this.elements[0] * this.elements[0] + this.elements[1] * this.elements[1] + this.elements[2] * this.elements[2]);
+			return Math.sqrt( this.elements[ 0 ] * this.elements[ 0 ] + this.elements[ 1 ] * this.elements[ 1 ] + this.elements[ 2 ] * this.elements[ 2 ] );
 
-    }
+		}
 
-  };
+	};
 
 
-  var suite = Bench.newSuite("Vector 3 Storage");
+	var suite = Bench.newSuite( 'Vector 3 Storage' );
 
-  suite.add('Vector3-Set', function() {
+	suite.add( 'Vector3-Set', function () {
 
-    var array = [];
-    for (var i = 0; i < 100000; i++) {
-      var v = new THREE.Vector3(i, i, i);
-      array.push(v);
-    }
+		var array = [];
+		for ( var i = 0; i < 100000; i ++ ) {
 
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      var v = array[i];
-      result += v.length();
-    }
-  });
+			var v = new THREE.Vector3( i, i, i );
+			array.push( v );
 
-  suite.add('Vector3-Float32Array', function() {
+		}
 
-    var array = [];
-    for (var i = 0; i < 100000; i++) {
-      var v = new THREE.Vector3X(i, i, i);
-      array.push(v);
-    }
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
 
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      var v = array[i];
-      result += v.length();
-    }
-  });
+			var v = array[ i ];
+			result += v.length();
 
-  suite.add('Vector3-Array', function() {
+		}
 
-    var array = [];
-    for (var i = 0; i < 100000; i++) {
-      var v = new THREE.Vector3Y(i, i, i);
-      array.push(v);
-    }
+	} );
 
-    var result = 0;
-    for (var i = 0; i < 100000; i++) {
-      var v = array[i];
-      result += v.length();
-    }
-  });
+	suite.add( 'Vector3-Float32Array', function () {
 
-})();
+		var array = [];
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			var v = new THREE.Vector3X( i, i, i );
+			array.push( v );
+
+		}
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			var v = array[ i ];
+			result += v.length();
+
+		}
+
+	} );
+
+	suite.add( 'Vector3-Array', function () {
+
+		var array = [];
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			var v = new THREE.Vector3Y( i, i, i );
+			array.push( v );
+
+		}
+
+		var result = 0;
+		for ( var i = 0; i < 100000; i ++ ) {
+
+			var v = array[ i ];
+			result += v.length();
+
+		}
+
+	} );
+
+} )();

test/unit/example/objects/Lensflare.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Objects', () => {
 	QUnit.module( 'Lensflare', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/AnimationAction.tests.js

@@ -12,8 +12,8 @@ function createAnimation() {
 
 	var root = new Object3D();
 	var mixer = new AnimationMixer( root );
-	var track = new NumberKeyframeTrack( ".rotation[x]", [ 0, 1000 ], [ 0, 360 ] );
-	var clip = new AnimationClip( "clip1", 1000, [ track ] );
+	var track = new NumberKeyframeTrack( '.rotation[x]', [ 0, 1000 ], [ 0, 360 ] );
+	var clip = new AnimationClip( 'clip1', 1000, [ track ] );
 
 	var animationAction = mixer.clipAction( clip );
 	return {
@@ -30,12 +30,12 @@ function createTwoAnimations() {
 
 	var root = new Object3D();
 	var mixer = new AnimationMixer( root );
-	var track = new NumberKeyframeTrack( ".rotation[x]", [ 0, 1000 ], [ 0, 360 ] );
-	var clip = new AnimationClip( "clip1", 1000, [ track ] );
+	var track = new NumberKeyframeTrack( '.rotation[x]', [ 0, 1000 ], [ 0, 360 ] );
+	var clip = new AnimationClip( 'clip1', 1000, [ track ] );
 	var animationAction = mixer.clipAction( clip );
 
-	var track2 = new NumberKeyframeTrack( ".rotation[y]", [ 0, 1000 ], [ 0, 360 ] );
-	var clip2 = new AnimationClip( "clip2", 1000, [ track ] );
+	var track2 = new NumberKeyframeTrack( '.rotation[y]', [ 0, 1000 ], [ 0, 360 ] );
+	var clip2 = new AnimationClip( 'clip2', 1000, [ track ] );
 	var animationAction2 = mixer.clipAction( clip2 );
 
 	return {
@@ -57,26 +57,26 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'AnimationAction', () => {
 
 		// INSTANCING
-		QUnit.test( "Instancing", ( assert ) => {
+		QUnit.test( 'Instancing', ( assert ) => {
 
 			var mixer = new AnimationMixer();
-			var clip = new AnimationClip( "nonname", - 1, [] );
+			var clip = new AnimationClip( 'nonname', - 1, [] );
 
 			var animationAction = new AnimationAction( mixer, clip );
-			assert.ok( animationAction, "animationAction instanciated" );
+			assert.ok( animationAction, 'animationAction instanciated' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.test( "play", ( assert ) => {
+		QUnit.test( 'play', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			var animationAction2 = animationAction.play();
-			assert.equal( animationAction, animationAction2, "AnimationAction.play can be chained." );
+			assert.equal( animationAction, animationAction2, 'AnimationAction.play can be chained.' );
 
 			var UserException = function () {
 
-				this.message = "AnimationMixer must activate AnimationAction on play.";
+				this.message = 'AnimationMixer must activate AnimationAction on play.';
 
 			};
 
@@ -98,15 +98,15 @@ export default QUnit.module( 'Animation', () => {
 
 		} );
 
-		QUnit.test( "stop", ( assert ) => {
+		QUnit.test( 'stop', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			var animationAction2 = animationAction.stop();
-			assert.equal( animationAction, animationAction2, "AnimationAction.stop can be chained." );
+			assert.equal( animationAction, animationAction2, 'AnimationAction.stop can be chained.' );
 
 			var UserException = function () {
 
-				this.message = "AnimationMixer must deactivate AnimationAction on stop.";
+				this.message = 'AnimationMixer must deactivate AnimationAction on stop.';
 
 			};
 
@@ -128,319 +128,319 @@ export default QUnit.module( 'Animation', () => {
 
 		} );
 
-		QUnit.test( "reset", ( assert ) => {
+		QUnit.test( 'reset', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			var animationAction2 = animationAction.stop();
-			assert.equal( animationAction, animationAction2, "AnimationAction.reset can be chained." );
-			assert.equal( animationAction2.paused, false, "AnimationAction.reset() sets paused false" );
-			assert.equal( animationAction2.enabled, true, "AnimationAction.reset() sets enabled true" );
-			assert.equal( animationAction2.time, 0, "AnimationAction.reset() resets time." );
-			assert.equal( animationAction2._loopCount, - 1, "AnimationAction.reset() resets loopcount." );
-			assert.equal( animationAction2._startTime, null, "AnimationAction.reset() removes starttime." );
+			assert.equal( animationAction, animationAction2, 'AnimationAction.reset can be chained.' );
+			assert.equal( animationAction2.paused, false, 'AnimationAction.reset() sets paused false' );
+			assert.equal( animationAction2.enabled, true, 'AnimationAction.reset() sets enabled true' );
+			assert.equal( animationAction2.time, 0, 'AnimationAction.reset() resets time.' );
+			assert.equal( animationAction2._loopCount, - 1, 'AnimationAction.reset() resets loopcount.' );
+			assert.equal( animationAction2._startTime, null, 'AnimationAction.reset() removes starttime.' );
 
 		} );
 
-		QUnit.test( "isRunning", ( assert ) => {
+		QUnit.test( 'isRunning', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
-			assert.notOk( animationAction.isRunning(), "When an animation is just made, it is not running." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is just made, it is not running.' );
 			animationAction.play();
-			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
+			assert.ok( animationAction.isRunning(), 'When an animation is started, it is running.' );
 			animationAction.stop();
-			assert.notOk( animationAction.isRunning(), "When an animation is stopped, it is not running." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is stopped, it is not running.' );
 			animationAction.play();
 			animationAction.paused = true;
-			assert.notOk( animationAction.isRunning(), "When an animation is paused, it is not running." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is paused, it is not running.' );
 			animationAction.paused = false;
 			animationAction.enabled = false;
-			assert.notOk( animationAction.isRunning(), "When an animation is not enabled, it is not running." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is not enabled, it is not running.' );
 			animationAction.enabled = true;
-			assert.ok( animationAction.isRunning(), "When an animation is enabled, it is running." );
+			assert.ok( animationAction.isRunning(), 'When an animation is enabled, it is running.' );
 
 		} );
 
-		QUnit.test( "isScheduled", ( assert ) => {
+		QUnit.test( 'isScheduled', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
-			assert.notOk( animationAction.isScheduled(), "When an animation is just made, it is not scheduled." );
+			assert.notOk( animationAction.isScheduled(), 'When an animation is just made, it is not scheduled.' );
 			animationAction.play();
-			assert.ok( animationAction.isScheduled(), "When an animation is started, it is scheduled." );
+			assert.ok( animationAction.isScheduled(), 'When an animation is started, it is scheduled.' );
 			mixer.update( 1 );
-			assert.ok( animationAction.isScheduled(), "When an animation is updated, it is scheduled." );
+			assert.ok( animationAction.isScheduled(), 'When an animation is updated, it is scheduled.' );
 			animationAction.stop();
-			assert.notOk( animationAction.isScheduled(), "When an animation is stopped, it isn't scheduled anymore." );
+			assert.notOk( animationAction.isScheduled(), 'When an animation is stopped, it isn\'t scheduled anymore.' );
 
 
 		} );
 
-		QUnit.test( "startAt", ( assert ) => {
+		QUnit.test( 'startAt', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			animationAction.startAt( 2 );
 			animationAction.play();
-			assert.notOk( animationAction.isRunning(), "When an animation is started at a specific time, it is not running." );
-			assert.ok( animationAction.isScheduled(), "When an animation is started at a specific time, it is scheduled." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is started at a specific time, it is not running.' );
+			assert.ok( animationAction.isScheduled(), 'When an animation is started at a specific time, it is scheduled.' );
 			mixer.update( 1 );
-			assert.notOk( animationAction.isRunning(), "When an animation is started at a specific time and the interval is not passed, it is not running." );
-			assert.ok( animationAction.isScheduled(), "When an animation is started at a specific time and the interval is not passed, it is scheduled." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is started at a specific time and the interval is not passed, it is not running.' );
+			assert.ok( animationAction.isScheduled(), 'When an animation is started at a specific time and the interval is not passed, it is scheduled.' );
 			mixer.update( 1 );
-			assert.ok( animationAction.isRunning(), "When an animation is started at a specific time and the interval is passed, it is running." );
-			assert.ok( animationAction.isScheduled(), "When an animation is started at a specific time and the interval is passed, it is scheduled." );
+			assert.ok( animationAction.isRunning(), 'When an animation is started at a specific time and the interval is passed, it is running.' );
+			assert.ok( animationAction.isScheduled(), 'When an animation is started at a specific time and the interval is passed, it is scheduled.' );
 			animationAction.stop();
-			assert.notOk( animationAction.isRunning(), "When an animation is stopped, it is not running." );
-			assert.notOk( animationAction.isScheduled(), "When an animation is stopped, it is not scheduled." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is stopped, it is not running.' );
+			assert.notOk( animationAction.isScheduled(), 'When an animation is stopped, it is not scheduled.' );
 
 
 		} );
 
-		QUnit.test( "setLoop LoopOnce", ( assert ) => {
+		QUnit.test( 'setLoop LoopOnce', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			animationAction.setLoop( LoopOnce );
 			animationAction.play();
-			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
+			assert.ok( animationAction.isRunning(), 'When an animation is started, it is running.' );
 			mixer.update( 500 );
-			assert.ok( animationAction.isRunning(), "When an animation is in the first loop, it is running." );
+			assert.ok( animationAction.isRunning(), 'When an animation is in the first loop, it is running.' );
 			mixer.update( 500 );
-			assert.notOk( animationAction.isRunning(), "When an animation is ended, it is not running." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is ended, it is not running.' );
 			mixer.update( 500 );
-			assert.notOk( animationAction.isRunning(), "When an animation is ended, it is not running." );
+			assert.notOk( animationAction.isRunning(), 'When an animation is ended, it is not running.' );
 
 		} );
 
-		QUnit.test( "setLoop LoopRepeat", ( assert ) => {
+		QUnit.test( 'setLoop LoopRepeat', ( assert ) => {
 
 			var { root, mixer, animationAction } = createAnimation();
 			animationAction.setLoop( LoopRepeat, 3 );
 			animationAction.play();
-			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
+			assert.ok( animationAction.isRunning(), 'When an animation is started, it is running.' );
 			mixer.update( 750 );
-			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopRepeat." );
-			assert.ok( animationAction.isRunning(), "When an animation is in the first loop, it is running." );
+			assert.equal( root.rotation.x, 270, 'When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopRepeat.' );
+			assert.ok( animationAction.isRunning(), 'When an animation is in the first loop, it is running.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the second loop, it has changed to 3/4 when LoopRepeat." );
-			assert.ok( animationAction.isRunning(), "When an animation is in second loop when in looprepeat 3 times, it is running." );
+			assert.equal( root.rotation.x, 270, 'When an animation is 3/4 in the second loop, it has changed to 3/4 when LoopRepeat.' );
+			assert.ok( animationAction.isRunning(), 'When an animation is in second loop when in looprepeat 3 times, it is running.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopRepeat." );
-			assert.ok( animationAction.isRunning(), "When an animation is in third loop when in looprepeat 3 times, it is running." );
+			assert.equal( root.rotation.x, 270, 'When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopRepeat.' );
+			assert.ok( animationAction.isRunning(), 'When an animation is in third loop when in looprepeat 3 times, it is running.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 0, "When an animation ended his third loop when in looprepeat 3 times, it stays on the end result." );
-			assert.notOk( animationAction.isRunning(), "When an animation ended his third loop when in looprepeat 3 times, it stays not running anymore." );
+			assert.equal( root.rotation.x, 0, 'When an animation ended his third loop when in looprepeat 3 times, it stays on the end result.' );
+			assert.notOk( animationAction.isRunning(), 'When an animation ended his third loop when in looprepeat 3 times, it stays not running anymore.' );
 
 		} );
 
-		QUnit.test( "setLoop LoopPingPong", ( assert ) => {
+		QUnit.test( 'setLoop LoopPingPong', ( assert ) => {
 
 			var { root, mixer, animationAction } = createAnimation();
 			animationAction.setLoop( LoopPingPong, 3 );
 			animationAction.play();
-			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
+			assert.ok( animationAction.isRunning(), 'When an animation is started, it is running.' );
 			mixer.update( 750 );
-			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopPingPong." );
-			assert.ok( animationAction.isRunning(), "When an animation is in the first loop, it is running." );
+			assert.equal( root.rotation.x, 270, 'When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopPingPong.' );
+			assert.ok( animationAction.isRunning(), 'When an animation is in the first loop, it is running.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 90, "When an animation is 3/4 in the second loop, it has changed to 1/4 when LoopPingPong." );
-			assert.ok( animationAction.isRunning(), "When an animation is in second loop when in looprepeat 3 times, it is running." );
+			assert.equal( root.rotation.x, 90, 'When an animation is 3/4 in the second loop, it has changed to 1/4 when LoopPingPong.' );
+			assert.ok( animationAction.isRunning(), 'When an animation is in second loop when in looprepeat 3 times, it is running.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopPingPong." );
-			assert.ok( animationAction.isRunning(), "When an animation is in third loop when in looprepeat 3 times, it is running." );
+			assert.equal( root.rotation.x, 270, 'When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopPingPong.' );
+			assert.ok( animationAction.isRunning(), 'When an animation is in third loop when in looprepeat 3 times, it is running.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 0, "When an animation ended his fourth loop when in looprepeat 3 times, it stays on the end result." );
-			assert.notOk( animationAction.isRunning(), "When an animation ended his fourth loop when in looprepeat 3 times, it stays not running anymore." );
+			assert.equal( root.rotation.x, 0, 'When an animation ended his fourth loop when in looprepeat 3 times, it stays on the end result.' );
+			assert.notOk( animationAction.isRunning(), 'When an animation ended his fourth loop when in looprepeat 3 times, it stays not running anymore.' );
 
 		} );
 
-		QUnit.test( "setEffectiveWeight", ( assert ) => {
+		QUnit.test( 'setEffectiveWeight', ( assert ) => {
 
 			var { animationAction } = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation is created, EffectiveWeight is 1.' );
 			animationAction.setEffectiveWeight( 0.3 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.3, "When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.3, 'When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3.' );
 
 
 			var { animationAction } = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation is created, EffectiveWeight is 1.' );
 			animationAction.enabled = false;
 			animationAction.setEffectiveWeight( 0.3 );
-			assert.equal( animationAction.getEffectiveWeight(), 0, "When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0." );
+			assert.equal( animationAction.getEffectiveWeight(), 0, 'When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0.' );
 
 
 			var { root, mixer, animationAction } = createAnimation();
 			animationAction.setEffectiveWeight( 0.5 );
 			animationAction.play();
 			mixer.update( 500 );
-			assert.equal( root.rotation.x, 90, "When an animation has weight 0.5 and runs half through the animation, it has changed to 1/4." );
+			assert.equal( root.rotation.x, 90, 'When an animation has weight 0.5 and runs half through the animation, it has changed to 1/4.' );
 			mixer.update( 1000 );
-			assert.equal( root.rotation.x, 90, "When an animation has weight 0.5 and runs one and half through the animation, it has changed to 1/4." );
+			assert.equal( root.rotation.x, 90, 'When an animation has weight 0.5 and runs one and half through the animation, it has changed to 1/4.' );
 
 		} );
 
-		QUnit.test( "getEffectiveWeight", ( assert ) => {
+		QUnit.test( 'getEffectiveWeight', ( assert ) => {
 
 			var { animationAction } = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation is created, EffectiveWeight is 1.' );
 			animationAction.setEffectiveWeight( 0.3 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.3, "When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.3, 'When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3.' );
 
 
 			var { animationAction } = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation is created, EffectiveWeight is 1.' );
 			animationAction.enabled = false;
 			animationAction.setEffectiveWeight( 0.3 );
-			assert.equal( animationAction.getEffectiveWeight(), 0, "When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0." );
+			assert.equal( animationAction.getEffectiveWeight(), 0, 'When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0.' );
 
 		} );
 
-		QUnit.test( "fadeIn", ( assert ) => {
+		QUnit.test( 'fadeIn', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			animationAction.fadeIn( 1000 );
 			animationAction.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeIn is started, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation fadeIn is started, EffectiveWeight is 1.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeIn happened 1/4, EffectiveWeight is 0.25." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.25, 'When an animation fadeIn happened 1/4, EffectiveWeight is 0.25.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeIn is halfway , EffectiveWeight is 0.5." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.5, 'When an animation fadeIn is halfway , EffectiveWeight is 0.5.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeIn is halfway , EffectiveWeight is 0.75." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.75, 'When an animation fadeIn is halfway , EffectiveWeight is 0.75.' );
 			mixer.update( 500 );
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeIn is ended , EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation fadeIn is ended , EffectiveWeight is 1.' );
 
 		} );
 
-		QUnit.test( "fadeOut", ( assert ) => {
+		QUnit.test( 'fadeOut', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			animationAction.fadeOut( 1000 );
 			animationAction.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeOut is started, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation fadeOut is started, EffectiveWeight is 1.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.75, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeOut is halfway , EffectiveWeight is 0.5." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.5, 'When an animation fadeOut is halfway , EffectiveWeight is 0.5.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.25, 'When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25.' );
 			mixer.update( 500 );
-			assert.equal( animationAction.getEffectiveWeight(), 0, "When an animation fadeOut is ended , EffectiveWeight is 0." );
+			assert.equal( animationAction.getEffectiveWeight(), 0, 'When an animation fadeOut is ended , EffectiveWeight is 0.' );
 
 		} );
 
-		QUnit.test( "crossFadeFrom", ( assert ) => {
+		QUnit.test( 'crossFadeFrom', ( assert ) => {
 
 			var { mixer, animationAction, animationAction2 } = createTwoAnimations();
 			animationAction.crossFadeFrom( animationAction2, 1000, false );
 			animationAction.play();
 			animationAction2.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
-			assert.equal( animationAction2.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation crossFadeFrom is started, EffectiveWeight is 1.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 1, 'When an animation crossFadeFrom is started, EffectiveWeight is 1.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.25, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0.75, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0.5, "When an animation fadeOut is halfway , EffectiveWeight is 0.5." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.5, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0.5, 'When an animation fadeOut is halfway , EffectiveWeight is 0.5.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0.25, "When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.75, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0.25, 'When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25.' );
 			mixer.update( 500 );
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0, "When an animation fadeOut is ended , EffectiveWeight is 0." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0, 'When an animation fadeOut is ended , EffectiveWeight is 0.' );
 
 		} );
 
-		QUnit.test( "crossFadeTo", ( assert ) => {
+		QUnit.test( 'crossFadeTo', ( assert ) => {
 
 			var { mixer, animationAction, animationAction2 } = createTwoAnimations();
 			animationAction2.crossFadeTo( animationAction, 1000, false );
 			animationAction.play();
 			animationAction2.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
-			assert.equal( animationAction2.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation crossFadeFrom is started, EffectiveWeight is 1.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 1, 'When an animation crossFadeFrom is started, EffectiveWeight is 1.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.25, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0.75, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0.5, "When an animation fadeOut is halfway , EffectiveWeight is 0.5." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.5, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0.5, 'When an animation fadeOut is halfway , EffectiveWeight is 0.5.' );
 			mixer.update( 250 );
-			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0.25, "When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25." );
+			assert.equal( animationAction.getEffectiveWeight(), 0.75, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0.25, 'When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25.' );
 			mixer.update( 500 );
-			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			assert.equal( animationAction2.getEffectiveWeight(), 0, "When an animation fadeOut is ended , EffectiveWeight is 0." );
+			assert.equal( animationAction.getEffectiveWeight(), 1, 'When an animation fadeOut happened 1/4, EffectiveWeight is 0.75.' );
+			assert.equal( animationAction2.getEffectiveWeight(), 0, 'When an animation fadeOut is ended , EffectiveWeight is 0.' );
 
 		} );
 
-		QUnit.todo( "stopFading", ( assert ) => {
+		QUnit.todo( 'stopFading', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setEffectiveTimeScale", ( assert ) => {
+		QUnit.todo( 'setEffectiveTimeScale', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getEffectiveTimeScale", ( assert ) => {
+		QUnit.todo( 'getEffectiveTimeScale', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setDuration", ( assert ) => {
+		QUnit.todo( 'setDuration', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "syncWith", ( assert ) => {
+		QUnit.todo( 'syncWith', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "halt", ( assert ) => {
+		QUnit.todo( 'halt', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "warp", ( assert ) => {
+		QUnit.todo( 'warp', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "stopWarping", ( assert ) => {
+		QUnit.todo( 'stopWarping', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "getMixer", ( assert ) => {
+		QUnit.test( 'getMixer', ( assert ) => {
 
 			var { mixer, animationAction } = createAnimation();
 			var mixer2 = animationAction.getMixer();
-			assert.equal( mixer, mixer2, "mixer should be returned by getMixer." );
+			assert.equal( mixer, mixer2, 'mixer should be returned by getMixer.' );
 
 		} );
 
-		QUnit.test( "getClip", ( assert ) => {
+		QUnit.test( 'getClip', ( assert ) => {
 
 			var { clip, animationAction } = createAnimation();
 			var clip2 = animationAction.getClip();
-			assert.equal( clip, clip2, "clip should be returned by getClip." );
+			assert.equal( clip, clip2, 'clip should be returned by getClip.' );
 
 		} );
 
-		QUnit.test( "getRoot", ( assert ) => {
+		QUnit.test( 'getRoot', ( assert ) => {
 
 			var { root, animationAction } = createAnimation();
 			var root2 = animationAction.getRoot();
-			assert.equal( root, root2, "root should be returned by getRoot." );
+			assert.equal( root, root2, 'root should be returned by getRoot.' );
 
 		} );
 

test/unit/src/animation/AnimationClip.tests.js

@@ -7,71 +7,71 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'AnimationClip', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// STATIC STUFF
-		QUnit.todo( "parse", ( assert ) => {
+		QUnit.todo( 'parse', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "toJSON", ( assert ) => {
+		QUnit.todo( 'toJSON', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "CreateFromMorphTargetSequence", ( assert ) => {
+		QUnit.todo( 'CreateFromMorphTargetSequence', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "findByName", ( assert ) => {
+		QUnit.todo( 'findByName', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "CreateClipsFromMorphTargetSequences", ( assert ) => {
+		QUnit.todo( 'CreateClipsFromMorphTargetSequences', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "parseAnimation", ( assert ) => {
+		QUnit.todo( 'parseAnimation', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "resetDuration", ( assert ) => {
+		QUnit.todo( 'resetDuration', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "trim", ( assert ) => {
+		QUnit.todo( 'trim', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "optimize", ( assert ) => {
+		QUnit.todo( 'optimize', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "validate", ( assert ) => {
+		QUnit.todo( 'validate', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/AnimationMixer.tests.js

@@ -14,11 +14,11 @@ function getClips( pos1, pos2, scale1, scale2, dur ) {
 
 	const clips = [];
 
-	let track = new VectorKeyframeTrack( ".scale", [ 0, dur ], [ scale1.x, scale1.y, scale1.z, scale2.x, scale2.y, scale2.z ] );
-	clips.push( new AnimationClip( "scale", dur, [ track ] ) );
+	let track = new VectorKeyframeTrack( '.scale', [ 0, dur ], [ scale1.x, scale1.y, scale1.z, scale2.x, scale2.y, scale2.z ] );
+	clips.push( new AnimationClip( 'scale', dur, [ track ] ) );
 
-	track = new VectorKeyframeTrack( ".position", [ 0, dur ], [ pos1.x, pos1.y, pos1.z, pos2.x, pos2.y, pos2.z ] );
-	clips.push( new AnimationClip( "position", dur, [ track ] ) );
+	track = new VectorKeyframeTrack( '.position', [ 0, dur ], [ pos1.x, pos1.y, pos1.z, pos2.x, pos2.y, pos2.z ] );
+	clips.push( new AnimationClip( 'position', dur, [ track ] ) );
 
 	return clips;
 
@@ -29,33 +29,33 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'AnimationMixer', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "clipAction", ( assert ) => {
+		QUnit.todo( 'clipAction', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "existingAction", ( assert ) => {
+		QUnit.todo( 'existingAction', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "stopAllAction", ( assert ) => {
+		QUnit.test( 'stopAllAction', ( assert ) => {
 
 			const obj = new Object3D();
 			const animMixer = new AnimationMixer( obj );
@@ -71,51 +71,51 @@ export default QUnit.module( 'Animation', () => {
 			assert.ok(
 				! actionA.isRunning() &&
 				! actionB.isRunning(),
-				"All actions stopped" );
+				'All actions stopped' );
 			assert.ok(
 				obj.position.x == 0 &&
 				obj.position.y == 0 &&
 				obj.position.z == 0,
-				"Position reset as expected"
+				'Position reset as expected'
 			);
 			assert.ok(
 				obj.scale.x == 1 &&
 				obj.scale.y == 1 &&
 				obj.scale.z == 1,
-				"Scale reset as expected"
+				'Scale reset as expected'
 			);
 
 		} );
 
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "getRoot", ( assert ) => {
+		QUnit.test( 'getRoot', ( assert ) => {
 
 			const obj = new Object3D();
 			const animMixer = new AnimationMixer( obj );
-			assert.strictEqual( obj, animMixer.getRoot(), "Get original root object" );
+			assert.strictEqual( obj, animMixer.getRoot(), 'Get original root object' );
 
 		} );
 
-		QUnit.todo( "uncacheClip", ( assert ) => {
+		QUnit.todo( 'uncacheClip', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "uncacheRoot", ( assert ) => {
+		QUnit.todo( 'uncacheRoot', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "uncacheAction", ( assert ) => {
+		QUnit.todo( 'uncacheAction', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/AnimationObjectGroup.tests.js

@@ -4,9 +4,9 @@ import { AnimationObjectGroup } from '../../../../src/animation/AnimationObjectG
 import { Object3D } from '../../../../src/core/Object3D';
 import { PropertyBinding } from '../../../../src/animation/PropertyBinding';
 
-export default QUnit.module( "Animation", () => {
+export default QUnit.module( 'Animation', () => {
 
-	QUnit.module( "AnimationObjectGroup", () => {
+	QUnit.module( 'AnimationObjectGroup', () => {
 
 		var ObjectA = new Object3D(),
 			ObjectB = new Object3D(),
@@ -21,39 +21,39 @@ export default QUnit.module( "Animation", () => {
 			ParsedPathC = PropertyBinding.parseTrackName( PathC );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isAnimationObjectGroup", ( assert ) => {
+		QUnit.todo( 'isAnimationObjectGroup', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "add", ( assert ) => {
+		QUnit.todo( 'add', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "remove", ( assert ) => {
+		QUnit.todo( 'remove', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "uncache", ( assert ) => {
+		QUnit.todo( 'uncache', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
-		QUnit.test( "smoke test", ( assert ) => {
+		QUnit.test( 'smoke test', ( assert ) => {
 
 			var expect = function expect( testIndex, group, bindings, path, cached, roots ) {
 
@@ -72,23 +72,23 @@ export default QUnit.module( "Animation", () => {
 
 				}
 
-				assert.ok( pathsOk, QUnit.testIndex + " paths" );
-				assert.ok( nodesOk, QUnit.testIndex + " nodes" );
-				assert.ok( group.nCachedObjects_ === cached, QUnit.testIndex + " cache size" );
-				assert.ok( bindings.length - group.nCachedObjects_ === roots.length, QUnit.testIndex + " object count" );
+				assert.ok( pathsOk, QUnit.testIndex + ' paths' );
+				assert.ok( nodesOk, QUnit.testIndex + ' nodes' );
+				assert.ok( group.nCachedObjects_ === cached, QUnit.testIndex + ' cache size' );
+				assert.ok( bindings.length - group.nCachedObjects_ === roots.length, QUnit.testIndex + ' object count' );
 
 			};
 
 			// initial state
 
 			var groupA = new AnimationObjectGroup();
-			assert.ok( groupA instanceof AnimationObjectGroup, "constructor (w/o args)" );
+			assert.ok( groupA instanceof AnimationObjectGroup, 'constructor (w/o args)' );
 
 			var bindingsAA = groupA.subscribe_( PathA, ParsedPathA );
 			expect( 0, groupA, bindingsAA, PathA, 0, [] );
 
 			var groupB = new AnimationObjectGroup( ObjectA, ObjectB );
-			assert.ok( groupB instanceof AnimationObjectGroup, "constructor (with args)" );
+			assert.ok( groupB instanceof AnimationObjectGroup, 'constructor (with args)' );
 
 			var bindingsBB = groupB.subscribe_( PathB, ParsedPathB );
 			expect( 1, groupB, bindingsBB, PathB, 0, [ ObjectA, ObjectB ] );
@@ -127,7 +127,7 @@ export default QUnit.module( "Animation", () => {
 			var copyOfBindingsBC = bindingsBC.slice();
 			groupB.unsubscribe_( PathC );
 			groupB.add( ObjectC );
-			assert.deepEqual( bindingsBC, copyOfBindingsBC, "no more update after unsubscribe" );
+			assert.deepEqual( bindingsBC, copyOfBindingsBC, 'no more update after unsubscribe' );
 
 			// uncache active
 

test/unit/src/animation/AnimationUtils.tests.js

@@ -7,39 +7,39 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'AnimationUtils', () => {
 
 		// PUBLIC STUFF
-		QUnit.todo( "arraySlice", ( assert ) => {
+		QUnit.todo( 'arraySlice', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "convertArray", ( assert ) => {
+		QUnit.todo( 'convertArray', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "isTypedArray", ( assert ) => {
+		QUnit.todo( 'isTypedArray', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getKeyframeOrder", ( assert ) => {
+		QUnit.todo( 'getKeyframeOrder', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "sortedArray", ( assert ) => {
+		QUnit.todo( 'sortedArray', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "flattenJSON", ( assert ) => {
+		QUnit.todo( 'flattenJSON', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/KeyframeTrack.tests.js

@@ -8,89 +8,89 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'KeyframeTrack', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// STATIC STUFF
-		QUnit.todo( "toJSON", ( assert ) => {
+		QUnit.todo( 'toJSON', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "TimeBufferType", ( assert ) => {
+		QUnit.todo( 'TimeBufferType', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "ValueBufferType", ( assert ) => {
+		QUnit.todo( 'ValueBufferType', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "DefaultInterpolation", ( assert ) => {
+		QUnit.todo( 'DefaultInterpolation', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "InterpolantFactoryMethodDiscrete", ( assert ) => {
+		QUnit.todo( 'InterpolantFactoryMethodDiscrete', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "InterpolantFactoryMethodLinear", ( assert ) => {
+		QUnit.todo( 'InterpolantFactoryMethodLinear', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "InterpolantFactoryMethodSmooth", ( assert ) => {
+		QUnit.todo( 'InterpolantFactoryMethodSmooth', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setInterpolation", ( assert ) => {
+		QUnit.todo( 'setInterpolation', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getInterpolation", ( assert ) => {
+		QUnit.todo( 'getInterpolation', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getValueSize", ( assert ) => {
+		QUnit.todo( 'getValueSize', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "shift", ( assert ) => {
+		QUnit.todo( 'shift', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "scale", ( assert ) => {
+		QUnit.todo( 'scale', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "trim", ( assert ) => {
+		QUnit.todo( 'trim', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/PropertyBinding.tests.js

@@ -10,22 +10,22 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'PropertyBinding', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// STATIC STUFF
-		QUnit.todo( "Composite", ( assert ) => {
+		QUnit.todo( 'Composite', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "create", ( assert ) => {
+		QUnit.todo( 'create', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -282,40 +282,40 @@ export default QUnit.module( 'Animation', () => {
 
 		} );
 
-		QUnit.todo( "findNode", ( assert ) => {
+		QUnit.todo( 'findNode', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "BindingType", ( assert ) => {
+		QUnit.todo( 'BindingType', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "Versioning", ( assert ) => {
+		QUnit.todo( 'Versioning', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "GetterByBindingType", ( assert ) => {
+		QUnit.todo( 'GetterByBindingType', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "SetterByBindingTypeAndVersioning", ( assert ) => {
+		QUnit.todo( 'SetterByBindingTypeAndVersioning', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getValue", ( assert ) => {
+		QUnit.todo( 'getValue', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -356,15 +356,15 @@ export default QUnit.module( 'Animation', () => {
 
 		} );
 
-		QUnit.todo( "bind", ( assert ) => {
+		QUnit.todo( 'bind', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "unbind", ( assert ) => {
+		QUnit.todo( 'unbind', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/PropertyMixer.tests.js

@@ -7,34 +7,34 @@ export default QUnit.module( 'Animation', () => {
 	QUnit.module( 'PropertyMixer', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "accumulate", ( assert ) => {
+		QUnit.todo( 'accumulate', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "apply", ( assert ) => {
+		QUnit.todo( 'apply', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "saveOriginalState", ( assert ) => {
+		QUnit.todo( 'saveOriginalState', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "restoreOriginalState", ( assert ) => {
+		QUnit.todo( 'restoreOriginalState', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/animation/tracks/BooleanKeyframeTrack.tests.js

@@ -10,7 +10,7 @@ export default QUnit.module( 'Animation', () => {
 
 			QUnit.todo( 'write me !', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/animation/tracks/ColorKeyframeTrack.tests.js

@@ -10,7 +10,7 @@ export default QUnit.module( 'Animation', () => {
 
 			QUnit.todo( 'write me !', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/animation/tracks/NumberKeyframeTrack.tests.js

@@ -10,7 +10,7 @@ export default QUnit.module( 'Animation', () => {
 
 			QUnit.todo( 'write me !', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/animation/tracks/QuaternionKeyframeTrack.tests.js

@@ -10,7 +10,7 @@ export default QUnit.module( 'Animation', () => {
 
 			QUnit.todo( 'write me !', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/animation/tracks/StringKeyframeTrack.tests.js

@@ -10,7 +10,7 @@ export default QUnit.module( 'Animation', () => {
 
 			QUnit.todo( 'write me !', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/animation/tracks/VectorKeyframeTrack.tests.js

@@ -10,7 +10,7 @@ export default QUnit.module( 'Animation', () => {
 
 			QUnit.todo( 'write me !', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/audio/Audio.tests.js

@@ -7,131 +7,131 @@ export default QUnit.module( 'Audios', () => {
 	QUnit.module( 'Audio', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "getOutput", ( assert ) => {
+		QUnit.todo( 'getOutput', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setNodeSource", ( assert ) => {
+		QUnit.todo( 'setNodeSource', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setBuffer", ( assert ) => {
+		QUnit.todo( 'setBuffer', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "play", ( assert ) => {
+		QUnit.todo( 'play', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "pause", ( assert ) => {
+		QUnit.todo( 'pause', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "stop", ( assert ) => {
+		QUnit.todo( 'stop', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "connect", ( assert ) => {
+		QUnit.todo( 'connect', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "disconnect", ( assert ) => {
+		QUnit.todo( 'disconnect', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getFilters", ( assert ) => {
+		QUnit.todo( 'getFilters', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setFilters", ( assert ) => {
+		QUnit.todo( 'setFilters', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getFilter", ( assert ) => {
+		QUnit.todo( 'getFilter', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setFilter", ( assert ) => {
+		QUnit.todo( 'setFilter', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setPlaybackRate", ( assert ) => {
+		QUnit.todo( 'setPlaybackRate', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getPlaybackRate", ( assert ) => {
+		QUnit.todo( 'getPlaybackRate', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "onEnded", ( assert ) => {
+		QUnit.todo( 'onEnded', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getLoop", ( assert ) => {
+		QUnit.todo( 'getLoop', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setLoop", ( assert ) => {
+		QUnit.todo( 'setLoop', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getVolume", ( assert ) => {
+		QUnit.todo( 'getVolume', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setVolume", ( assert ) => {
+		QUnit.todo( 'setVolume', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/audio/AudioAnalyser.tests.js

@@ -7,22 +7,22 @@ export default QUnit.module( 'Audios', () => {
 	QUnit.module( 'AudioAnalyser', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "getFrequencyData", ( assert ) => {
+		QUnit.todo( 'getFrequencyData', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getAverageFrequency", ( assert ) => {
+		QUnit.todo( 'getAverageFrequency', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/audio/AudioContext.tests.js

@@ -7,15 +7,15 @@ export default QUnit.module( 'Audios', () => {
 	QUnit.module( 'AudioContext', () => {
 
 		// PUBLIC STUFF
-		QUnit.todo( "getContext", ( assert ) => {
+		QUnit.todo( 'getContext', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setContext", ( assert ) => {
+		QUnit.todo( 'setContext', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/audio/AudioListener.tests.js

@@ -7,59 +7,59 @@ export default QUnit.module( 'Audios', () => {
 	QUnit.module( 'AudioListener', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "getInput", ( assert ) => {
+		QUnit.todo( 'getInput', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "removeFilter", ( assert ) => {
+		QUnit.todo( 'removeFilter', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getFilter", ( assert ) => {
+		QUnit.todo( 'getFilter', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setFilter", ( assert ) => {
+		QUnit.todo( 'setFilter', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getMasterVolume", ( assert ) => {
+		QUnit.todo( 'getMasterVolume', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setMasterVolume", ( assert ) => {
+		QUnit.todo( 'setMasterVolume', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "updateMatrixWorld", ( assert ) => {
+		QUnit.todo( 'updateMatrixWorld', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/audio/PositionalAudio.tests.js

@@ -7,77 +7,77 @@ export default QUnit.module( 'Audios', () => {
 	QUnit.module( 'PositionalAudio', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "getOutput", ( assert ) => {
+		QUnit.todo( 'getOutput', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getRefDistance", ( assert ) => {
+		QUnit.todo( 'getRefDistance', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setRefDistance", ( assert ) => {
+		QUnit.todo( 'setRefDistance', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getRolloffFactor", ( assert ) => {
+		QUnit.todo( 'getRolloffFactor', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setRolloffFactor", ( assert ) => {
+		QUnit.todo( 'setRolloffFactor', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getDistanceModel", ( assert ) => {
+		QUnit.todo( 'getDistanceModel', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setDistanceModel", ( assert ) => {
+		QUnit.todo( 'setDistanceModel', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getMaxDistance", ( assert ) => {
+		QUnit.todo( 'getMaxDistance', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setMaxDistance", ( assert ) => {
+		QUnit.todo( 'setMaxDistance', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "updateMatrixWorld", ( assert ) => {
+		QUnit.todo( 'updateMatrixWorld', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/cameras/ArrayCamera.tests.js

@@ -7,23 +7,23 @@ export default QUnit.module( 'Cameras', () => {
 	QUnit.module( 'ArrayCamera', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isArrayCamera", ( assert ) => {
+		QUnit.todo( 'isArrayCamera', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/cameras/Camera.tests.js

@@ -8,45 +8,45 @@ export default QUnit.module( 'Cameras', () => {
 	QUnit.module( 'Camera', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isCamera", ( assert ) => {
+		QUnit.todo( 'isCamera', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "copy", ( assert ) => {
+		QUnit.todo( 'copy', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getWorldDirection", ( assert ) => {
+		QUnit.todo( 'getWorldDirection', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "updateMatrixWorld", ( assert ) => {
+		QUnit.todo( 'updateMatrixWorld', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "clone", ( assert ) => {
+		QUnit.test( 'clone', ( assert ) => {
 
 			var cam = new Camera();
 
@@ -59,19 +59,19 @@ export default QUnit.module( 'Cameras', () => {
 			// TODO: Uuuummmhhh DO NOT relie equality on object methods !
 			// TODO: What's append if matrix.equal is wrongly implemented ???
 			// TODO: this MUST be check by assert
-			assert.ok( cam.matrixWorldInverse.equals( clonedCam.matrixWorldInverse ), "matrixWorldInverse is equal" );
-			assert.ok( cam.projectionMatrix.equals( clonedCam.projectionMatrix ), "projectionMatrix is equal" );
+			assert.ok( cam.matrixWorldInverse.equals( clonedCam.matrixWorldInverse ), 'matrixWorldInverse is equal' );
+			assert.ok( cam.projectionMatrix.equals( clonedCam.projectionMatrix ), 'projectionMatrix is equal' );
 
 		} );
 
 		// OTHERS
 		// TODO: this should not be here !!! This is Object3D stuff !!!
-		QUnit.test( "lookAt", ( assert ) => {
+		QUnit.test( 'lookAt', ( assert ) => {
 
 			var cam = new Camera();
 			cam.lookAt( new Vector3( 0, 1, - 1 ) );
 
-			assert.numEqual( cam.rotation.x * ( 180 / Math.PI ), 45, "x is equal" );
+			assert.numEqual( cam.rotation.x * ( 180 / Math.PI ), 45, 'x is equal' );
 
 		} );
 

test/unit/src/cameras/CubeCamera.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Cameras', () => {
 	QUnit.module( 'CubeCamera', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/cameras/OrthographicCamera.tests.js

@@ -7,45 +7,45 @@ export default QUnit.module( 'Cameras', () => {
 	QUnit.module( 'OrthographicCamera', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isOrthographicCamera", ( assert ) => {
+		QUnit.todo( 'isOrthographicCamera', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "copy", ( assert ) => {
+		QUnit.todo( 'copy', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setViewOffset", ( assert ) => {
+		QUnit.todo( 'setViewOffset', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "clearViewOffset", ( assert ) => {
+		QUnit.todo( 'clearViewOffset', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "updateProjectionMatrix", ( assert ) => {
+		QUnit.test( 'updateProjectionMatrix', ( assert ) => {
 
 			var left = - 1, right = 1, top = 1, bottom = - 1, near = 1, far = 3;
 			var cam = new OrthographicCamera( left, right, top, bottom, near, far );
@@ -59,37 +59,37 @@ export default QUnit.module( 'Cameras', () => {
 			//   0			0		-2/f-n	-(f+n/f-n)
 			//   0			0			 0				1
 
-			assert.ok( pMatrix[ 0 ] === 2 / ( right - left ), "m[0,0] === 2 / (r - l)" );
-			assert.ok( pMatrix[ 5 ] === 2 / ( top - bottom ), "m[1,1] === 2 / (t - b)" );
-			assert.ok( pMatrix[ 10 ] === - 2 / ( far - near ), "m[2,2] === -2 / (f - n)" );
-			assert.ok( pMatrix[ 12 ] === - ( ( right + left ) / ( right - left ) ), "m[3,0] === -(r+l/r-l)" );
-			assert.ok( pMatrix[ 13 ] === - ( ( top + bottom ) / ( top - bottom ) ), "m[3,1] === -(t+b/b-t)" );
-			assert.ok( pMatrix[ 14 ] === - ( ( far + near ) / ( far - near ) ), "m[3,2] === -(f+n/f-n)" );
+			assert.ok( pMatrix[ 0 ] === 2 / ( right - left ), 'm[0,0] === 2 / (r - l)' );
+			assert.ok( pMatrix[ 5 ] === 2 / ( top - bottom ), 'm[1,1] === 2 / (t - b)' );
+			assert.ok( pMatrix[ 10 ] === - 2 / ( far - near ), 'm[2,2] === -2 / (f - n)' );
+			assert.ok( pMatrix[ 12 ] === - ( ( right + left ) / ( right - left ) ), 'm[3,0] === -(r+l/r-l)' );
+			assert.ok( pMatrix[ 13 ] === - ( ( top + bottom ) / ( top - bottom ) ), 'm[3,1] === -(t+b/b-t)' );
+			assert.ok( pMatrix[ 14 ] === - ( ( far + near ) / ( far - near ) ), 'm[3,2] === -(f+n/f-n)' );
 
 		} );
 
-		QUnit.todo( "toJSON", ( assert ) => {
+		QUnit.todo( 'toJSON', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
 		// TODO: no no no clone is a camera methods that relied to copy method
-		QUnit.test( "clone", ( assert ) => {
+		QUnit.test( 'clone', ( assert ) => {
 
 			var left = - 1.5, right = 1.5, top = 1, bottom = - 1, near = 0.1, far = 42;
 			var cam = new OrthographicCamera( left, right, top, bottom, near, far );
 
 			var clonedCam = cam.clone();
 
-			assert.ok( cam.left === clonedCam.left, "left is equal" );
-			assert.ok( cam.right === clonedCam.right, "right is equal" );
-			assert.ok( cam.top === clonedCam.top, "top is equal" );
-			assert.ok( cam.bottom === clonedCam.bottom, "bottom is equal" );
-			assert.ok( cam.near === clonedCam.near, "near is equal" );
-			assert.ok( cam.far === clonedCam.far, "far is equal" );
-			assert.ok( cam.zoom === clonedCam.zoom, "zoom is equal" );
+			assert.ok( cam.left === clonedCam.left, 'left is equal' );
+			assert.ok( cam.right === clonedCam.right, 'right is equal' );
+			assert.ok( cam.top === clonedCam.top, 'top is equal' );
+			assert.ok( cam.bottom === clonedCam.bottom, 'bottom is equal' );
+			assert.ok( cam.near === clonedCam.near, 'near is equal' );
+			assert.ok( cam.far === clonedCam.far, 'far is equal' );
+			assert.ok( cam.zoom === clonedCam.zoom, 'zoom is equal' );
 
 		} );
 

test/unit/src/cameras/PerspectiveCamera.tests.js

@@ -16,6 +16,7 @@ export default QUnit.module( 'Cameras', () => {
 				return false;
 
 			}
+
 			for ( var i = 0, il = a.elements.length; i < il; i ++ ) {
 
 				var delta = a.elements[ i ] - b.elements[ i ];
@@ -32,75 +33,75 @@ export default QUnit.module( 'Cameras', () => {
 		};
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isPerspectiveCamera", ( assert ) => {
+		QUnit.todo( 'isPerspectiveCamera', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "copy", ( assert ) => {
+		QUnit.todo( 'copy', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setFocalLength", ( assert ) => {
+		QUnit.todo( 'setFocalLength', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getFocalLength", ( assert ) => {
+		QUnit.todo( 'getFocalLength', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getEffectiveFOV", ( assert ) => {
+		QUnit.todo( 'getEffectiveFOV', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getFilmWidth", ( assert ) => {
+		QUnit.todo( 'getFilmWidth', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getFilmHeight", ( assert ) => {
+		QUnit.todo( 'getFilmHeight', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setViewOffset", ( assert ) => {
+		QUnit.todo( 'setViewOffset', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "clearViewOffset", ( assert ) => {
+		QUnit.todo( 'clearViewOffset', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "updateProjectionMatrix", ( assert ) => {
+		QUnit.test( 'updateProjectionMatrix', ( assert ) => {
 
 			var cam = new PerspectiveCamera( 75, 16 / 9, 0.1, 300.0 );
 
@@ -127,15 +128,15 @@ export default QUnit.module( 'Cameras', () => {
 
 		} );
 
-		QUnit.todo( "toJSON", ( assert ) => {
+		QUnit.todo( 'toJSON', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
 		// TODO: no no no clone is a camera methods that relied to copy method
-		QUnit.test( "clone", ( assert ) => {
+		QUnit.test( 'clone', ( assert ) => {
 
 			var near = 1,
 				far = 3,
@@ -146,12 +147,12 @@ export default QUnit.module( 'Cameras', () => {
 
 			var clonedCam = cam.clone();
 
-			assert.ok( cam.fov === clonedCam.fov, "fov is equal" );
-			assert.ok( cam.aspect === clonedCam.aspect, "aspect is equal" );
-			assert.ok( cam.near === clonedCam.near, "near is equal" );
-			assert.ok( cam.far === clonedCam.far, "far is equal" );
-			assert.ok( cam.zoom === clonedCam.zoom, "zoom is equal" );
-			assert.ok( cam.projectionMatrix.equals( clonedCam.projectionMatrix ), "projectionMatrix is equal" );
+			assert.ok( cam.fov === clonedCam.fov, 'fov is equal' );
+			assert.ok( cam.aspect === clonedCam.aspect, 'aspect is equal' );
+			assert.ok( cam.near === clonedCam.near, 'near is equal' );
+			assert.ok( cam.far === clonedCam.far, 'far is equal' );
+			assert.ok( cam.zoom === clonedCam.zoom, 'zoom is equal' );
+			assert.ok( cam.projectionMatrix.equals( clonedCam.projectionMatrix ), 'projectionMatrix is equal' );
 
 		} );
 

test/unit/src/cameras/StereoCamera.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Cameras', () => {
 	QUnit.module( 'StereoCamera', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/constants.tests.js

@@ -4,7 +4,7 @@ import * as Constants from '../../../src/constants';
 
 export default QUnit.module( 'Constants', () => {
 
-	QUnit.test( "default values", ( assert ) => {
+	QUnit.test( 'default values', ( assert ) => {
 
 		assert.propEqual( Constants.MOUSE, { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 }, 'MOUSE equal { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 }' );
 		assert.propEqual( Constants.TOUCH, { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 }, 'TOUCH equal { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 }' );
@@ -103,20 +103,20 @@ export default QUnit.module( 'Constants', () => {
 		assert.equal( Constants.RGBA_PVRTC_4BPPV1_Format, 35842, 'RGBA_PVRTC_4BPPV1_Format is equal to 35842' );
 		assert.equal( Constants.RGBA_PVRTC_2BPPV1_Format, 35843, 'RGBA_PVRTC_2BPPV1_Format is equal to 35843' );
 		assert.equal( Constants.RGB_ETC1_Format, 36196, 'RGB_ETC1_Format is equal to 36196' );
-		assert.equal( Constants.RGBA_ASTC_4x4_Format, 37808, "Constants.RGBA_ASTC_4x4_Format is equal to 37808" );
-		assert.equal( Constants.RGBA_ASTC_5x4_Format, 37809, "Constants.RGBA_ASTC_5x4_Format is equal to 37809" );
-		assert.equal( Constants.RGBA_ASTC_5x5_Format, 37810, "Constants.RGBA_ASTC_5x5_Format is equal to 37810" );
-		assert.equal( Constants.RGBA_ASTC_6x5_Format, 37811, "Constants.RGBA_ASTC_6x5_Format is equal to 37811" );
-		assert.equal( Constants.RGBA_ASTC_6x6_Format, 37812, "Constants.RGBA_ASTC_6x6_Format is equal to 37812" );
-		assert.equal( Constants.RGBA_ASTC_8x5_Format, 37813, "Constants.RGBA_ASTC_8x5_Format is equal to 37813" );
-		assert.equal( Constants.RGBA_ASTC_8x6_Format, 37814, "Constants.RGBA_ASTC_8x6_Format is equal to 37814" );
-		assert.equal( Constants.RGBA_ASTC_8x8_Format, 37815, "Constants.RGBA_ASTC_8x8_Format is equal to 37815" );
-		assert.equal( Constants.RGBA_ASTC_10x5_Format, 37816, "Constants.RGBA_ASTC_10x5_Format is equal to 37816" );
-		assert.equal( Constants.RGBA_ASTC_10x6_Format, 37817, "Constants.RGBA_ASTC_10x6_Format is equal to 37817" );
-		assert.equal( Constants.RGBA_ASTC_10x8_Format, 37818, "Constants.RGBA_ASTC_10x8_Format is equal to 37818" );
-		assert.equal( Constants.RGBA_ASTC_10x10_Format, 37819, "Constants.RGBA_ASTC_10x10_Format is equal to 37819" );
-		assert.equal( Constants.RGBA_ASTC_12x10_Format, 37820, "Constants.RGBA_ASTC_12x10_Format is equal to 37820" );
-		assert.equal( Constants.RGBA_ASTC_12x12_Format, 37821, "Constants.RGBA_ASTC_12x12_Format is equal to 37821" );
+		assert.equal( Constants.RGBA_ASTC_4x4_Format, 37808, 'Constants.RGBA_ASTC_4x4_Format is equal to 37808' );
+		assert.equal( Constants.RGBA_ASTC_5x4_Format, 37809, 'Constants.RGBA_ASTC_5x4_Format is equal to 37809' );
+		assert.equal( Constants.RGBA_ASTC_5x5_Format, 37810, 'Constants.RGBA_ASTC_5x5_Format is equal to 37810' );
+		assert.equal( Constants.RGBA_ASTC_6x5_Format, 37811, 'Constants.RGBA_ASTC_6x5_Format is equal to 37811' );
+		assert.equal( Constants.RGBA_ASTC_6x6_Format, 37812, 'Constants.RGBA_ASTC_6x6_Format is equal to 37812' );
+		assert.equal( Constants.RGBA_ASTC_8x5_Format, 37813, 'Constants.RGBA_ASTC_8x5_Format is equal to 37813' );
+		assert.equal( Constants.RGBA_ASTC_8x6_Format, 37814, 'Constants.RGBA_ASTC_8x6_Format is equal to 37814' );
+		assert.equal( Constants.RGBA_ASTC_8x8_Format, 37815, 'Constants.RGBA_ASTC_8x8_Format is equal to 37815' );
+		assert.equal( Constants.RGBA_ASTC_10x5_Format, 37816, 'Constants.RGBA_ASTC_10x5_Format is equal to 37816' );
+		assert.equal( Constants.RGBA_ASTC_10x6_Format, 37817, 'Constants.RGBA_ASTC_10x6_Format is equal to 37817' );
+		assert.equal( Constants.RGBA_ASTC_10x8_Format, 37818, 'Constants.RGBA_ASTC_10x8_Format is equal to 37818' );
+		assert.equal( Constants.RGBA_ASTC_10x10_Format, 37819, 'Constants.RGBA_ASTC_10x10_Format is equal to 37819' );
+		assert.equal( Constants.RGBA_ASTC_12x10_Format, 37820, 'Constants.RGBA_ASTC_12x10_Format is equal to 37820' );
+		assert.equal( Constants.RGBA_ASTC_12x12_Format, 37821, 'Constants.RGBA_ASTC_12x12_Format is equal to 37821' );
 		assert.equal( Constants.LoopOnce, 2200, 'LoopOnce is equal to 2200' );
 		assert.equal( Constants.LoopRepeat, 2201, 'LoopRepeat is equal to 2201' );
 		assert.equal( Constants.LoopPingPong, 2202, 'LoopPingPong is equal to 2202' );

test/unit/src/core/BufferAttribute.tests.js

@@ -12,7 +12,7 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'BufferAttribute', () => {
 
 		// INSTANCING
-		QUnit.test( "Instancing", ( assert ) => {
+		QUnit.test( 'Instancing', ( assert ) => {
 
 			assert.throws(
 				function () {
@@ -21,35 +21,35 @@ export default QUnit.module( 'Core', () => {
 
 				},
 				/array should be a Typed Array/,
-				"Calling constructor with a simple array throws Error"
+				'Calling constructor with a simple array throws Error'
 			);
 
 		} );
 
 		// PROPERTIES
-		QUnit.todo( "needsUpdate", ( assert ) => {
+		QUnit.todo( 'needsUpdate', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isBufferAttribute", ( assert ) => {
+		QUnit.todo( 'isBufferAttribute', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "setUsage", ( assert ) => {
+		QUnit.test( 'setUsage', ( assert ) => {
 
 			var attr = new BufferAttribute();
 			attr.setUsage( DynamicDrawUsage );
 
-			assert.strictEqual( attr.usage, DynamicDrawUsage, "Usage was set" );
+			assert.strictEqual( attr.usage, DynamicDrawUsage, 'Usage was set' );
 
 		} );
 
-		QUnit.test( "copy", ( assert ) => {
+		QUnit.test( 'copy', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 );
 			attr.setUsage( DynamicDrawUsage );
@@ -65,7 +65,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyAt", ( assert ) => {
+		QUnit.test( 'copyAt', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ), 3 );
 			var attr2 = new BufferAttribute( new Float32Array( 9 ), 3 );
@@ -83,18 +83,18 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyArray", ( assert ) => {
+		QUnit.test( 'copyArray', ( assert ) => {
 
 			var f32a = new Float32Array( [ 5, 6, 7, 8 ] );
 			var a = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4 ] ), 2, false );
 
 			a.copyArray( f32a );
 
-			assert.deepEqual( a.array, f32a, "Check array has new values" );
+			assert.deepEqual( a.array, f32a, 'Check array has new values' );
 
 		} );
 
-		QUnit.test( "copyColorsArray", ( assert ) => {
+		QUnit.test( 'copyColorsArray', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( 6 ), 3 );
 
@@ -109,7 +109,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyVector2sArray", ( assert ) => {
+		QUnit.test( 'copyVector2sArray', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( 4 ), 2 );
 
@@ -124,7 +124,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyVector3sArray", ( assert ) => {
+		QUnit.test( 'copyVector3sArray', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( 6 ), 2 );
 
@@ -139,7 +139,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyVector4sArray", ( assert ) => {
+		QUnit.test( 'copyVector4sArray', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( 8 ), 2 );
 
@@ -154,7 +154,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "set", ( assert ) => {
+		QUnit.test( 'set', ( assert ) => {
 
 			var f32a = new Float32Array( [ 1, 2, 3, 4 ] );
 			var a = new BufferAttribute( f32a, 2, false );
@@ -163,11 +163,11 @@ export default QUnit.module( 'Core', () => {
 			a.set( [ 9 ] );
 			a.set( [ 8 ], 2 );
 
-			assert.deepEqual( a.array, expected, "Check array has expected values" );
+			assert.deepEqual( a.array, expected, 'Check array has expected values' );
 
 		} );
 
-		QUnit.test( "set[X, Y, Z, W, XYZ, XYZW]/get[X, Y, Z, W]", ( assert ) => {
+		QUnit.test( 'set[X, Y, Z, W, XYZ, XYZW]/get[X, Y, Z, W]', ( assert ) => {
 
 			var f32a = new Float32Array( [ 1, 2, 3, 4, 5, 6, 7, 8 ] );
 			var a = new BufferAttribute( f32a, 4, false );
@@ -178,11 +178,11 @@ export default QUnit.module( 'Core', () => {
 			a.setZ( 0, a.getZ( 0 ) * - 1 );
 			a.setW( 0, a.getW( 0 ) * - 1 );
 
-			assert.deepEqual( a.array, expected, "Check all set* calls set the correct values" );
+			assert.deepEqual( a.array, expected, 'Check all set* calls set the correct values' );
 
 		} );
 
-		QUnit.test( "setXY", ( assert ) => {
+		QUnit.test( 'setXY', ( assert ) => {
 
 			var f32a = new Float32Array( [ 1, 2, 3, 4 ] );
 			var a = new BufferAttribute( f32a, 2, false );
@@ -190,11 +190,11 @@ export default QUnit.module( 'Core', () => {
 
 			a.setXY( 0, - 1, - 2 );
 
-			assert.deepEqual( a.array, expected, "Check for the correct values" );
+			assert.deepEqual( a.array, expected, 'Check for the correct values' );
 
 		} );
 
-		QUnit.test( "setXYZ", ( assert ) => {
+		QUnit.test( 'setXYZ', ( assert ) => {
 
 			var f32a = new Float32Array( [ 1, 2, 3, 4, 5, 6 ] );
 			var a = new BufferAttribute( f32a, 3, false );
@@ -202,11 +202,11 @@ export default QUnit.module( 'Core', () => {
 
 			a.setXYZ( 1, - 4, - 5, - 6 );
 
-			assert.deepEqual( a.array, expected, "Check for the correct values" );
+			assert.deepEqual( a.array, expected, 'Check for the correct values' );
 
 		} );
 
-		QUnit.test( "setXYZW", ( assert ) => {
+		QUnit.test( 'setXYZW', ( assert ) => {
 
 			var f32a = new Float32Array( [ 1, 2, 3, 4 ] );
 			var a = new BufferAttribute( f32a, 4, false );
@@ -214,22 +214,22 @@ export default QUnit.module( 'Core', () => {
 
 			a.setXYZW( 0, - 1, - 2, - 3, - 4 );
 
-			assert.deepEqual( a.array, expected, "Check for the correct values" );
+			assert.deepEqual( a.array, expected, 'Check for the correct values' );
 
 		} );
 
-		QUnit.test( "onUpload", ( assert ) => {
+		QUnit.test( 'onUpload', ( assert ) => {
 
 			var a = new BufferAttribute();
 			var func = function () { };
 
 			a.onUpload( func );
 
-			assert.strictEqual( a.onUploadCallback, func, "Check callback was set properly" );
+			assert.strictEqual( a.onUploadCallback, func, 'Check callback was set properly' );
 
 		} );
 
-		QUnit.test( "clone", ( assert ) => {
+		QUnit.test( 'clone', ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 0.12, - 12 ] ), 2 );
 			var attrCopy = attr.clone();
@@ -243,7 +243,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "toJSON", ( assert ) => {
+		QUnit.test( 'toJSON', ( assert ) => {
 
 			const attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 );
 			assert.deepEqual( attr.toJSON(), {
@@ -271,7 +271,7 @@ export default QUnit.module( 'Core', () => {
 		} );
 
 		// OTHERS
-		QUnit.test( "count", ( assert ) => {
+		QUnit.test( 'count', ( assert ) => {
 
 			assert.ok(
 				new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ).count === 2,
@@ -285,16 +285,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Int8BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -303,16 +303,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint8BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -321,16 +321,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint8ClampedBufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -339,16 +339,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Int16BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -357,16 +357,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint16BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -375,16 +375,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Int32BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -393,16 +393,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint32BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -411,16 +411,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Float32BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
@@ -429,16 +429,16 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Float64BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/core/BufferGeometry.tests.js

@@ -48,7 +48,7 @@ function getBBForVertices( vertices ) {
 
 	var geometry = new BufferGeometry();
 
-	geometry.setAttribute( "position", new BufferAttribute( new Float32Array( vertices ), 3 ) );
+	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( vertices ), 3 ) );
 	geometry.computeBoundingBox();
 
 	return geometry.boundingBox;
@@ -59,7 +59,7 @@ function getBSForVertices( vertices ) {
 
 	var geometry = new BufferGeometry();
 
-	geometry.setAttribute( "position", new BufferAttribute( new Float32Array( vertices ), 3 ) );
+	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( vertices ), 3 ) );
 	geometry.computeBoundingSphere();
 
 	return geometry.boundingSphere;
@@ -70,11 +70,11 @@ function getNormalsForVertices( vertices, assert ) {
 
 	var geometry = new BufferGeometry();
 
-	geometry.setAttribute( "position", new BufferAttribute( new Float32Array( vertices ), 3 ) );
+	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( vertices ), 3 ) );
 
 	geometry.computeVertexNormals();
 
-	assert.ok( geometry.attributes.normal !== undefined, "normal attribute was created" );
+	assert.ok( geometry.attributes.normal !== undefined, 'normal attribute was created' );
 
 	return geometry.attributes.normal.array;
 
@@ -85,56 +85,56 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'BufferGeometry', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isBufferGeometry", ( assert ) => {
+		QUnit.todo( 'isBufferGeometry', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "setIndex/getIndex", ( assert ) => {
+		QUnit.test( 'setIndex/getIndex', ( assert ) => {
 
 			var a = new BufferGeometry();
 			var uint16 = [ 1, 2, 3 ];
 			var uint32 = [ 65535, 65536, 65537 ];
-			var str = "foo";
+			var str = 'foo';
 
 			a.setIndex( uint16 );
-			assert.ok( a.getIndex() instanceof Uint16BufferAttribute, "Index has the right type" );
-			assert.deepEqual( a.getIndex().array, new Uint16Array( uint16 ), "Small index gets stored correctly" );
+			assert.ok( a.getIndex() instanceof Uint16BufferAttribute, 'Index has the right type' );
+			assert.deepEqual( a.getIndex().array, new Uint16Array( uint16 ), 'Small index gets stored correctly' );
 
 			a.setIndex( uint32 );
-			assert.ok( a.getIndex() instanceof Uint32BufferAttribute, "Index has the right type" );
-			assert.deepEqual( a.getIndex().array, new Uint32Array( uint32 ), "Large index gets stored correctly" );
+			assert.ok( a.getIndex() instanceof Uint32BufferAttribute, 'Index has the right type' );
+			assert.deepEqual( a.getIndex().array, new Uint32Array( uint32 ), 'Large index gets stored correctly' );
 
 			a.setIndex( str );
-			assert.strictEqual( a.getIndex(), str, "Weird index gets stored correctly" );
+			assert.strictEqual( a.getIndex(), str, 'Weird index gets stored correctly' );
 
 		} );
 
-		QUnit.todo( "getAttribute", ( assert ) => {
+		QUnit.todo( 'getAttribute', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "set / delete Attribute", ( assert ) => {
+		QUnit.test( 'set / delete Attribute', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			var attributeName = "position";
+			var attributeName = 'position';
 
 			assert.ok( geometry.attributes[ attributeName ] === undefined, 'no attribute defined' );
 
@@ -148,7 +148,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "addGroup", ( assert ) => {
+		QUnit.test( 'addGroup', ( assert ) => {
 
 			var a = new BufferGeometry();
 			var expected = [
@@ -167,19 +167,19 @@ export default QUnit.module( 'Core', () => {
 			a.addGroup( 0, 1, 0 );
 			a.addGroup( 1, 2, 2 );
 
-			assert.deepEqual( a.groups, expected, "Check groups were stored correctly and in order" );
+			assert.deepEqual( a.groups, expected, 'Check groups were stored correctly and in order' );
 
 			a.clearGroups();
-			assert.strictEqual( a.groups.length, 0, "Check groups were deleted correctly" );
+			assert.strictEqual( a.groups.length, 0, 'Check groups were deleted correctly' );
 
 		} );
-		QUnit.todo( "clearGroups", ( assert ) => {
+		QUnit.todo( 'clearGroups', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "setDrawRange", ( assert ) => {
+		QUnit.test( 'setDrawRange', ( assert ) => {
 
 			var a = new BufferGeometry();
 
@@ -188,14 +188,14 @@ export default QUnit.module( 'Core', () => {
 			assert.deepEqual( a.drawRange, {
 				start: 1,
 				count: 7
-			}, "Check draw range was stored correctly" );
+			}, 'Check draw range was stored correctly' );
 
 		} );
 
-		QUnit.test( "applyMatrix4", ( assert ) => {
+		QUnit.test( 'applyMatrix4', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "position", new BufferAttribute( new Float32Array( 6 ), 3 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 6 ), 3 ) );
 
 			var matrix = new Matrix4().set(
 				1, 0, 0, 1.5,
@@ -207,16 +207,16 @@ export default QUnit.module( 'Core', () => {
 
 			var position = geometry.attributes.position.array;
 			var m = matrix.elements;
-			assert.ok( position[ 0 ] === m[ 12 ] && position[ 1 ] === m[ 13 ] && position[ 2 ] === m[ 14 ], "position was extracted from matrix" );
-			assert.ok( position[ 3 ] === m[ 12 ] && position[ 4 ] === m[ 13 ] && position[ 5 ] === m[ 14 ], "position was extracted from matrix twice" );
-			assert.ok( geometry.attributes.position.version === 1, "version was increased during update" );
+			assert.ok( position[ 0 ] === m[ 12 ] && position[ 1 ] === m[ 13 ] && position[ 2 ] === m[ 14 ], 'position was extracted from matrix' );
+			assert.ok( position[ 3 ] === m[ 12 ] && position[ 4 ] === m[ 13 ] && position[ 5 ] === m[ 14 ], 'position was extracted from matrix twice' );
+			assert.ok( geometry.attributes.position.version === 1, 'version was increased during update' );
 
 		} );
 
-		QUnit.test( "applyQuaternion", ( assert ) => {
+		QUnit.test( 'applyQuaternion', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "position", new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
 
 			var q = new Quaternion( 0.5, 0.5, 0.5, 0.5 );
 			geometry.applyQuaternion( q );
@@ -225,13 +225,14 @@ export default QUnit.module( 'Core', () => {
 
 			// geometry was rotated around the (1, 1, 1) axis.
 			assert.ok( pos[ 0 ] === 3 && pos[ 1 ] === 1 && pos[ 2 ] === 2 &&
-				pos[ 3 ] === 6 && pos[ 4 ] === 4 && pos[ 5 ] === 5, "vertices were rotated properly" );
+				pos[ 3 ] === 6 && pos[ 4 ] === 4 && pos[ 5 ] === 5, 'vertices were rotated properly' );
+
 		} );
 
-		QUnit.test( "rotateX/Y/Z", ( assert ) => {
+		QUnit.test( 'rotateX/Y/Z', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "position", new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
 
 			var pos = geometry.attributes.position.array;
 
@@ -239,51 +240,51 @@ export default QUnit.module( 'Core', () => {
 
 			// object was rotated around x so all items should be flipped but the x ones
 			assert.ok( pos[ 0 ] === 1 && pos[ 1 ] === - 2 && pos[ 2 ] === - 3 &&
-				pos[ 3 ] === 4 && pos[ 4 ] === - 5 && pos[ 5 ] === - 6, "vertices were rotated around x by 180 degrees" );
+				pos[ 3 ] === 4 && pos[ 4 ] === - 5 && pos[ 5 ] === - 6, 'vertices were rotated around x by 180 degrees' );
 
 			geometry.rotateY( 180 * DegToRad );
 
 			// vertices were rotated around y so all items should be flipped again but the y ones
 			assert.ok( pos[ 0 ] === - 1 && pos[ 1 ] === - 2 && pos[ 2 ] === 3 &&
-				pos[ 3 ] === - 4 && pos[ 4 ] === - 5 && pos[ 5 ] === 6, "vertices were rotated around y by 180 degrees" );
+				pos[ 3 ] === - 4 && pos[ 4 ] === - 5 && pos[ 5 ] === 6, 'vertices were rotated around y by 180 degrees' );
 
 			geometry.rotateZ( 180 * DegToRad );
 
 			// vertices were rotated around z so all items should be flipped again but the z ones
 			assert.ok( pos[ 0 ] === 1 && pos[ 1 ] === 2 && pos[ 2 ] === 3 &&
-				pos[ 3 ] === 4 && pos[ 4 ] === 5 && pos[ 5 ] === 6, "vertices were rotated around z by 180 degrees" );
+				pos[ 3 ] === 4 && pos[ 4 ] === 5 && pos[ 5 ] === 6, 'vertices were rotated around z by 180 degrees' );
 
 		} );
 
-		QUnit.test( "translate", ( assert ) => {
+		QUnit.test( 'translate', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "position", new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
 
 			var pos = geometry.attributes.position.array;
 
 			geometry.translate( 10, 20, 30 );
 
 			assert.ok( pos[ 0 ] === 11 && pos[ 1 ] === 22 && pos[ 2 ] === 33 &&
-				pos[ 3 ] === 14 && pos[ 4 ] === 25 && pos[ 5 ] === 36, "vertices were translated" );
+				pos[ 3 ] === 14 && pos[ 4 ] === 25 && pos[ 5 ] === 36, 'vertices were translated' );
 
 		} );
 
-		QUnit.test( "scale", ( assert ) => {
+		QUnit.test( 'scale', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "position", new BufferAttribute( new Float32Array( [ - 1, - 1, - 1, 2, 2, 2 ] ), 3 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ - 1, - 1, - 1, 2, 2, 2 ] ), 3 ) );
 
 			var pos = geometry.attributes.position.array;
 
 			geometry.scale( 1, 2, 3 );
 
 			assert.ok( pos[ 0 ] === - 1 && pos[ 1 ] === - 2 && pos[ 2 ] === - 3 &&
-				pos[ 3 ] === 2 && pos[ 4 ] === 4 && pos[ 5 ] === 6, "vertices were scaled" );
+				pos[ 3 ] === 2 && pos[ 4 ] === 4 && pos[ 5 ] === 6, 'vertices were scaled' );
 
 		} );
 
-		QUnit.test( "lookAt", ( assert ) => {
+		QUnit.test( 'lookAt', ( assert ) => {
 
 			var a = new BufferGeometry();
 			var vertices = new Float32Array( [
@@ -310,14 +311,14 @@ export default QUnit.module( 'Core', () => {
 
 			a.lookAt( new Vector3( 0, 1, - 1 ) );
 
-			assert.ok( bufferAttributeEquals( a.attributes.position.array, expected ), "Rotation is correct" );
+			assert.ok( bufferAttributeEquals( a.attributes.position.array, expected ), 'Rotation is correct' );
 
 		} );
 
-		QUnit.test( "center", ( assert ) => {
+		QUnit.test( 'center', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "position", new BufferAttribute( new Float32Array( [
+			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [
 				- 1, - 1, - 1,
 				1, 1, 1,
 				4, 4, 4
@@ -331,64 +332,64 @@ export default QUnit.module( 'Core', () => {
 			// after centering it the vertices should be placed between (-2.5, -2.5, -2.5) and (2.5, 2.5, 2.5)
 			assert.ok( pos[ 0 ] === - 2.5 && pos[ 1 ] === - 2.5 && pos[ 2 ] === - 2.5 &&
 				pos[ 3 ] === - 0.5 && pos[ 4 ] === - 0.5 && pos[ 5 ] === - 0.5 &&
-				pos[ 6 ] === 2.5 && pos[ 7 ] === 2.5 && pos[ 8 ] === 2.5, "vertices were replaced by boundingBox dimensions" );
+				pos[ 6 ] === 2.5 && pos[ 7 ] === 2.5 && pos[ 8 ] === 2.5, 'vertices were replaced by boundingBox dimensions' );
 
 		} );
 
-		QUnit.test( "computeBoundingBox", ( assert ) => {
+		QUnit.test( 'computeBoundingBox', ( assert ) => {
 
 			var bb = getBBForVertices( [ - 1, - 2, - 3, 13, - 2, - 3.5, - 1, - 20, 0, - 4, 5, 6 ] );
 
-			assert.ok( bb.min.x === - 4 && bb.min.y === - 20 && bb.min.z === - 3.5, "min values are set correctly" );
-			assert.ok( bb.max.x === 13 && bb.max.y === 5 && bb.max.z === 6, "max values are set correctly" );
+			assert.ok( bb.min.x === - 4 && bb.min.y === - 20 && bb.min.z === - 3.5, 'min values are set correctly' );
+			assert.ok( bb.max.x === 13 && bb.max.y === 5 && bb.max.z === 6, 'max values are set correctly' );
 
 			var bb = getBBForVertices( [ - 1, - 1, - 1 ] );
 
-			assert.ok( bb.min.x === bb.max.x && bb.min.y === bb.max.y && bb.min.z === bb.max.z, "since there is only one vertex, max and min are equal" );
-			assert.ok( bb.min.x === - 1 && bb.min.y === - 1 && bb.min.z === - 1, "since there is only one vertex, min and max are this vertex" );
+			assert.ok( bb.min.x === bb.max.x && bb.min.y === bb.max.y && bb.min.z === bb.max.z, 'since there is only one vertex, max and min are equal' );
+			assert.ok( bb.min.x === - 1 && bb.min.y === - 1 && bb.min.z === - 1, 'since there is only one vertex, min and max are this vertex' );
 
 		} );
 
-		QUnit.test( "computeBoundingSphere", ( assert ) => {
+		QUnit.test( 'computeBoundingSphere', ( assert ) => {
 
 			var bs = getBSForVertices( [ - 10, 0, 0, 10, 0, 0 ] );
 
-			assert.ok( bs.radius === ( 10 + 10 ) / 2, "radius is equal to deltaMinMax / 2" );
-			assert.ok( bs.center.x === 0 && bs.center.y === 0 && bs.center.y === 0, "bounding sphere is at ( 0, 0, 0 )" );
+			assert.ok( bs.radius === ( 10 + 10 ) / 2, 'radius is equal to deltaMinMax / 2' );
+			assert.ok( bs.center.x === 0 && bs.center.y === 0 && bs.center.y === 0, 'bounding sphere is at ( 0, 0, 0 )' );
 
 			var bs = getBSForVertices( [ - 5, 11, - 3, 5, - 11, 3 ] );
 			var radius = new Vector3( 5, 11, 3 ).length();
 
-			assert.ok( bs.radius === radius, "radius is equal to directionLength" );
-			assert.ok( bs.center.x === 0 && bs.center.y === 0 && bs.center.y === 0, "bounding sphere is at ( 0, 0, 0 )" );
+			assert.ok( bs.radius === radius, 'radius is equal to directionLength' );
+			assert.ok( bs.center.x === 0 && bs.center.y === 0 && bs.center.y === 0, 'bounding sphere is at ( 0, 0, 0 )' );
 
 		} );
 
-		QUnit.test( "computeVertexNormals", ( assert ) => {
+		QUnit.test( 'computeVertexNormals', ( assert ) => {
 
 			// get normals for a counter clockwise created triangle
 			var normals = getNormalsForVertices( [ - 1, 0, 0, 1, 0, 0, 0, 1, 0 ], assert );
 
 			assert.ok( normals[ 0 ] === 0 && normals[ 1 ] === 0 && normals[ 2 ] === 1,
-				"first normal is pointing to screen since the the triangle was created counter clockwise" );
+				'first normal is pointing to screen since the the triangle was created counter clockwise' );
 
 			assert.ok( normals[ 3 ] === 0 && normals[ 4 ] === 0 && normals[ 5 ] === 1,
-				"second normal is pointing to screen since the the triangle was created counter clockwise" );
+				'second normal is pointing to screen since the the triangle was created counter clockwise' );
 
 			assert.ok( normals[ 6 ] === 0 && normals[ 7 ] === 0 && normals[ 8 ] === 1,
-				"third normal is pointing to screen since the the triangle was created counter clockwise" );
+				'third normal is pointing to screen since the the triangle was created counter clockwise' );
 
 			// get normals for a clockwise created triangle
 			var normals = getNormalsForVertices( [ 1, 0, 0, - 1, 0, 0, 0, 1, 0 ], assert );
 
 			assert.ok( normals[ 0 ] === 0 && normals[ 1 ] === 0 && normals[ 2 ] === - 1,
-				"first normal is pointing to screen since the the triangle was created clockwise" );
+				'first normal is pointing to screen since the the triangle was created clockwise' );
 
 			assert.ok( normals[ 3 ] === 0 && normals[ 4 ] === 0 && normals[ 5 ] === - 1,
-				"second normal is pointing to screen since the the triangle was created clockwise" );
+				'second normal is pointing to screen since the the triangle was created clockwise' );
 
 			assert.ok( normals[ 6 ] === 0 && normals[ 7 ] === 0 && normals[ 8 ] === - 1,
-				"third normal is pointing to screen since the the triangle was created clockwise" );
+				'third normal is pointing to screen since the the triangle was created clockwise' );
 
 			var normals = getNormalsForVertices( [ 0, 0, 1, 0, 0, - 1, 1, 1, 0 ], assert );
 
@@ -400,18 +401,18 @@ export default QUnit.module( 'Core', () => {
 			// which can be taken from Number.EPSILON
 			var direction = new Vector3( 1, 1, 0 ).normalize(); // a vector which should have 90 degrees difference to normals
 			var difference = direction.dot( new Vector3( normals[ 0 ], normals[ 1 ], normals[ 2 ] ) );
-			assert.ok( difference < Number.EPSILON, "normal is equal to reference vector" );
+			assert.ok( difference < Number.EPSILON, 'normal is equal to reference vector' );
 
 			// get normals for a line should be NAN because you need min a triangle to calculate normals
 			var normals = getNormalsForVertices( [ 1, 0, 0, - 1, 0, 0 ], assert );
 			for ( var i = 0; i < normals.length; i ++ ) {
 
-				assert.ok( ! normals[ i ], "normals can't be calculated which is good" );
+				assert.ok( ! normals[ i ], 'normals can\'t be calculated which is good' );
 
 			}
 
 		} );
-		QUnit.test( "computeVertexNormals (indexed)", ( assert ) => {
+		QUnit.test( 'computeVertexNormals (indexed)', ( assert ) => {
 
 			var sqrt = 0.5 * Math.sqrt( 2 );
 			var normal = new BufferAttribute( new Float32Array( [
@@ -429,36 +430,36 @@ export default QUnit.module( 'Core', () => {
 			] ), 1 );
 
 			var a = new BufferGeometry();
-			a.setAttribute( "position", position );
+			a.setAttribute( 'position', position );
 			a.computeVertexNormals();
 			assert.ok(
-				bufferAttributeEquals( normal, a.getAttribute( "normal" ) ),
-				"Regular geometry: first computed normals are correct"
+				bufferAttributeEquals( normal, a.getAttribute( 'normal' ) ),
+				'Regular geometry: first computed normals are correct'
 			);
 
 			// a second time to see if the existing normals get properly deleted
 			a.computeVertexNormals();
 			assert.ok(
-				bufferAttributeEquals( normal, a.getAttribute( "normal" ) ),
-				"Regular geometry: second computed normals are correct"
+				bufferAttributeEquals( normal, a.getAttribute( 'normal' ) ),
+				'Regular geometry: second computed normals are correct'
 			);
 
 			// indexed geometry
 			var a = new BufferGeometry();
-			a.setAttribute( "position", position );
+			a.setAttribute( 'position', position );
 			a.setIndex( index );
 			a.computeVertexNormals();
-			assert.ok( bufferAttributeEquals( normal, a.getAttribute( "normal" ) ), "Indexed geometry: computed normals are correct" );
+			assert.ok( bufferAttributeEquals( normal, a.getAttribute( 'normal' ) ), 'Indexed geometry: computed normals are correct' );
 
 		} );
 
-		QUnit.test( "merge", ( assert ) => {
+		QUnit.test( 'merge', ( assert ) => {
 
 			var geometry1 = new BufferGeometry();
-			geometry1.setAttribute( "attrName", new BufferAttribute( new Float32Array( [ 1, 2, 3, 0, 0, 0 ] ), 3 ) );
+			geometry1.setAttribute( 'attrName', new BufferAttribute( new Float32Array( [ 1, 2, 3, 0, 0, 0 ] ), 3 ) );
 
 			var geometry2 = new BufferGeometry();
-			geometry2.setAttribute( "attrName", new BufferAttribute( new Float32Array( [ 4, 5, 6 ] ), 3 ) );
+			geometry2.setAttribute( 'attrName', new BufferAttribute( new Float32Array( [ 4, 5, 6 ] ), 3 ) );
 
 			var attr = geometry1.attributes.attrName.array;
 
@@ -467,7 +468,7 @@ export default QUnit.module( 'Core', () => {
 			// merged array should be 1, 2, 3, 4, 5, 6
 			for ( var i = 0; i < attr.length; i ++ ) {
 
-				assert.ok( attr[ i ] === i + 1, "" );
+				assert.ok( attr[ i ] === i + 1, '' );
 
 			}
 
@@ -475,17 +476,17 @@ export default QUnit.module( 'Core', () => {
 			geometry1.merge( geometry2 );
 			console.level = CONSOLE_LEVEL.DEFAULT;
 
-			assert.ok( attr[ 0 ] === 4 && attr[ 1 ] === 5 && attr[ 2 ] === 6, "copied the 3 attributes without offset" );
+			assert.ok( attr[ 0 ] === 4 && attr[ 1 ] === 5 && attr[ 2 ] === 6, 'copied the 3 attributes without offset' );
 
 		} );
 
-		QUnit.todo( "normalizeNormals", ( assert ) => {
+		QUnit.todo( 'normalizeNormals', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "toNonIndexed", ( assert ) => {
+		QUnit.test( 'toNonIndexed', ( assert ) => {
 
 			var geometry = new BufferGeometry();
 			var vertices = new Float32Array( [
@@ -502,136 +503,136 @@ export default QUnit.module( 'Core', () => {
 
 			var nonIndexed = geometry.toNonIndexed();
 
-			assert.deepEqual( nonIndexed.getAttribute( "position" ).array, expected, "Expected vertices" );
+			assert.deepEqual( nonIndexed.getAttribute( 'position' ).array, expected, 'Expected vertices' );
 
 		} );
 
-		QUnit.test( "toJSON", ( assert ) => {
+		QUnit.test( 'toJSON', ( assert ) => {
 
 			var index = new BufferAttribute( new Uint16Array( [ 0, 1, 2, 3 ] ), 1 );
 			var attribute1 = new BufferAttribute( new Uint16Array( [ 1, 3, 5, 7 ] ), 1 );
-			attribute1.name = "attribute1";
+			attribute1.name = 'attribute1';
 			var a = new BufferGeometry();
-			a.name = "JSONQUnit.test";
+			a.name = 'JSONQUnit.test';
 			// a.parameters = { "placeholder": 0 };
-			a.setAttribute( "attribute1", attribute1 );
+			a.setAttribute( 'attribute1', attribute1 );
 			a.setIndex( index );
 			a.addGroup( 0, 1, 2 );
 			a.boundingSphere = new Sphere( new Vector3( x, y, z ), 0.5 );
 			var j = a.toJSON();
 			var gold = {
-				"metadata": {
-					"version": 4.5,
-					"type": "BufferGeometry",
-					"generator": "BufferGeometry.toJSON"
+				'metadata': {
+					'version': 4.5,
+					'type': 'BufferGeometry',
+					'generator': 'BufferGeometry.toJSON'
 				},
-				"uuid": a.uuid,
-				"type": "BufferGeometry",
-				"name": "JSONQUnit.test",
-				"data": {
-					"attributes": {
-						"attribute1": {
-							"itemSize": 1,
-							"type": "Uint16Array",
-							"array": [ 1, 3, 5, 7 ],
-							"normalized": false,
-							"name": "attribute1"
+				'uuid': a.uuid,
+				'type': 'BufferGeometry',
+				'name': 'JSONQUnit.test',
+				'data': {
+					'attributes': {
+						'attribute1': {
+							'itemSize': 1,
+							'type': 'Uint16Array',
+							'array': [ 1, 3, 5, 7 ],
+							'normalized': false,
+							'name': 'attribute1'
 						}
 					},
-					"index": {
-						"type": "Uint16Array",
-						"array": [ 0, 1, 2, 3 ]
+					'index': {
+						'type': 'Uint16Array',
+						'array': [ 0, 1, 2, 3 ]
 					},
-					"groups": [
+					'groups': [
 						{
-							"start": 0,
-							"count": 1,
-							"materialIndex": 2
+							'start': 0,
+							'count': 1,
+							'materialIndex': 2
 						}
 					],
-					"boundingSphere": {
-						"center": [ 2, 3, 4 ],
-						"radius": 0.5
+					'boundingSphere': {
+						'center': [ 2, 3, 4 ],
+						'radius': 0.5
 					}
 				}
 			};
 
-			assert.deepEqual( j, gold, "Generated JSON is as expected" );
+			assert.deepEqual( j, gold, 'Generated JSON is as expected' );
 
 			// add morphAttributes
 			a.morphAttributes.attribute1 = [];
 			a.morphAttributes.attribute1.push( attribute1.clone() );
 			j = a.toJSON();
 			gold.data.morphAttributes = {
-				"attribute1": [ {
-					"itemSize": 1,
-					"type": "Uint16Array",
-					"array": [ 1, 3, 5, 7 ],
-					"normalized": false,
-					"name": "attribute1"
+				'attribute1': [ {
+					'itemSize': 1,
+					'type': 'Uint16Array',
+					'array': [ 1, 3, 5, 7 ],
+					'normalized': false,
+					'name': 'attribute1'
 				} ]
 			};
 			gold.data.morphTargetsRelative = false;
 
-			assert.deepEqual( j, gold, "Generated JSON with morphAttributes is as expected" );
+			assert.deepEqual( j, gold, 'Generated JSON with morphAttributes is as expected' );
 
 		} );
 
-		QUnit.test( "clone", ( assert ) => {
+		QUnit.test( 'clone', ( assert ) => {
 
 			var a = new BufferGeometry();
-			a.setAttribute( "attribute1", new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
-			a.setAttribute( "attribute2", new BufferAttribute( new Float32Array( [ 0, 1, 3, 5, 6 ] ), 1 ) );
+			a.setAttribute( 'attribute1', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
+			a.setAttribute( 'attribute2', new BufferAttribute( new Float32Array( [ 0, 1, 3, 5, 6 ] ), 1 ) );
 			a.addGroup( 0, 1, 2 );
 			a.computeBoundingBox();
 			a.computeBoundingSphere();
 			a.setDrawRange( 0, 1 );
 			var b = a.clone();
 
-			assert.notEqual( a, b, "A new object was created" );
-			assert.notEqual( a.id, b.id, "New object has a different GUID" );
+			assert.notEqual( a, b, 'A new object was created' );
+			assert.notEqual( a.id, b.id, 'New object has a different GUID' );
 
 			assert.strictEqual(
 				Object.keys( a.attributes ).count, Object.keys( b.attributes ).count,
-				"Both objects have the same amount of attributes"
+				'Both objects have the same amount of attributes'
 			);
 			assert.ok(
-				bufferAttributeEquals( a.getAttribute( "attribute1" ), b.getAttribute( "attribute1" ) ),
-				"First attributes buffer is identical"
+				bufferAttributeEquals( a.getAttribute( 'attribute1' ), b.getAttribute( 'attribute1' ) ),
+				'First attributes buffer is identical'
 			);
 			assert.ok(
-				bufferAttributeEquals( a.getAttribute( "attribute2" ), b.getAttribute( "attribute2" ) ),
-				"Second attributes buffer is identical"
+				bufferAttributeEquals( a.getAttribute( 'attribute2' ), b.getAttribute( 'attribute2' ) ),
+				'Second attributes buffer is identical'
 			);
 
-			assert.deepEqual( a.groups, b.groups, "Groups are identical" );
+			assert.deepEqual( a.groups, b.groups, 'Groups are identical' );
 
-			assert.ok( a.boundingBox.equals( b.boundingBox ), "BoundingBoxes are equal" );
-			assert.ok( a.boundingSphere.equals( b.boundingSphere ), "BoundingSpheres are equal" );
+			assert.ok( a.boundingBox.equals( b.boundingBox ), 'BoundingBoxes are equal' );
+			assert.ok( a.boundingSphere.equals( b.boundingSphere ), 'BoundingSpheres are equal' );
 
-			assert.strictEqual( a.drawRange.start, b.drawRange.start, "DrawRange start is identical" );
-			assert.strictEqual( a.drawRange.count, b.drawRange.count, "DrawRange count is identical" );
+			assert.strictEqual( a.drawRange.start, b.drawRange.start, 'DrawRange start is identical' );
+			assert.strictEqual( a.drawRange.count, b.drawRange.count, 'DrawRange count is identical' );
 
 		} );
 
-		QUnit.test( "copy", ( assert ) => {
+		QUnit.test( 'copy', ( assert ) => {
 
 			var geometry = new BufferGeometry();
-			geometry.setAttribute( "attrName", new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
-			geometry.setAttribute( "attrName2", new BufferAttribute( new Float32Array( [ 0, 1, 3, 5, 6 ] ), 1 ) );
+			geometry.setAttribute( 'attrName', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
+			geometry.setAttribute( 'attrName2', new BufferAttribute( new Float32Array( [ 0, 1, 3, 5, 6 ] ), 1 ) );
 
 			var copy = new BufferGeometry().copy( geometry );
 
-			assert.ok( copy !== geometry && geometry.id !== copy.id, "new object was created" );
+			assert.ok( copy !== geometry && geometry.id !== copy.id, 'new object was created' );
 
 			Object.keys( geometry.attributes ).forEach( function ( key ) {
 
 				var attribute = geometry.attributes[ key ];
-				assert.ok( attribute !== undefined, "all attributes where copied" );
+				assert.ok( attribute !== undefined, 'all attributes where copied' );
 
 				for ( var i = 0; i < attribute.array.length; i ++ ) {
 
-					assert.ok( attribute.array[ i ] === copy.attributes[ key ].array[ i ], "values of the attribute are equal" );
+					assert.ok( attribute.array[ i ] === copy.attributes[ key ].array[ i ], 'values of the attribute are equal' );
 
 				}
 
@@ -639,9 +640,9 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.todo( "dispose", ( assert ) => {
+		QUnit.todo( 'dispose', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/core/EventDispatcher.tests.js

@@ -7,66 +7,66 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'EventDispatcher', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.test( "addEventListener", ( assert ) => {
+		QUnit.test( 'addEventListener', ( assert ) => {
 
 			var eventDispatcher = new EventDispatcher();
 
 			var listener = {};
 			eventDispatcher.addEventListener( 'anyType', listener );
 
-			assert.ok( eventDispatcher._listeners.anyType.length === 1, "listener with unknown type was added" );
-			assert.ok( eventDispatcher._listeners.anyType[ 0 ] === listener, "listener with unknown type was added" );
+			assert.ok( eventDispatcher._listeners.anyType.length === 1, 'listener with unknown type was added' );
+			assert.ok( eventDispatcher._listeners.anyType[ 0 ] === listener, 'listener with unknown type was added' );
 
 			eventDispatcher.addEventListener( 'anyType', listener );
 
-			assert.ok( eventDispatcher._listeners.anyType.length === 1, "can't add one listener twice to same type" );
-			assert.ok( eventDispatcher._listeners.anyType[ 0 ] === listener, "listener is still there" );
+			assert.ok( eventDispatcher._listeners.anyType.length === 1, 'can\'t add one listener twice to same type' );
+			assert.ok( eventDispatcher._listeners.anyType[ 0 ] === listener, 'listener is still there' );
 
 		} );
 
-		QUnit.test( "hasEventListener", ( assert ) => {
+		QUnit.test( 'hasEventListener', ( assert ) => {
 
 			var eventDispatcher = new EventDispatcher();
 
 			var listener = {};
 			eventDispatcher.addEventListener( 'anyType', listener );
 
-			assert.ok( eventDispatcher.hasEventListener( 'anyType', listener ), "listener was found" );
-			assert.ok( ! eventDispatcher.hasEventListener( 'anotherType', listener ), "listener was not found which is good" );
+			assert.ok( eventDispatcher.hasEventListener( 'anyType', listener ), 'listener was found' );
+			assert.ok( ! eventDispatcher.hasEventListener( 'anotherType', listener ), 'listener was not found which is good' );
 
 		} );
 
-		QUnit.test( "removeEventListener", ( assert ) => {
+		QUnit.test( 'removeEventListener', ( assert ) => {
 
 			var eventDispatcher = new EventDispatcher();
 
 			var listener = {};
 
-			assert.ok( eventDispatcher._listeners === undefined, "there are no listeners by default" );
+			assert.ok( eventDispatcher._listeners === undefined, 'there are no listeners by default' );
 
 			eventDispatcher.addEventListener( 'anyType', listener );
 			assert.ok( Object.keys( eventDispatcher._listeners ).length === 1 &&
-				eventDispatcher._listeners.anyType.length === 1, "if a listener was added, there is a new key" );
+				eventDispatcher._listeners.anyType.length === 1, 'if a listener was added, there is a new key' );
 
 			eventDispatcher.removeEventListener( 'anyType', listener );
-			assert.ok( eventDispatcher._listeners.anyType.length === 0, "listener was deleted" );
+			assert.ok( eventDispatcher._listeners.anyType.length === 0, 'listener was deleted' );
 
 			eventDispatcher.removeEventListener( 'unknownType', listener );
-			assert.ok( eventDispatcher._listeners.unknownType === undefined, "unknown types will be ignored" );
+			assert.ok( eventDispatcher._listeners.unknownType === undefined, 'unknown types will be ignored' );
 
 			eventDispatcher.removeEventListener( 'anyType', undefined );
-			assert.ok( eventDispatcher._listeners.anyType.length === 0, "undefined listeners are ignored" );
+			assert.ok( eventDispatcher._listeners.anyType.length === 0, 'undefined listeners are ignored' );
 
 		} );
 
-		QUnit.test( "dispatchEvent", ( assert ) => {
+		QUnit.test( 'dispatchEvent', ( assert ) => {
 
 			var eventDispatcher = new EventDispatcher();
 
@@ -78,13 +78,13 @@ export default QUnit.module( 'Core', () => {
 			};
 
 			eventDispatcher.addEventListener( 'anyType', listener );
-			assert.ok( callCount === 0, "no event, no call" );
+			assert.ok( callCount === 0, 'no event, no call' );
 
 			eventDispatcher.dispatchEvent( { type: 'anyType' } );
-			assert.ok( callCount === 1, "one event, one call" );
+			assert.ok( callCount === 1, 'one event, one call' );
 
 			eventDispatcher.dispatchEvent( { type: 'anyType' } );
-			assert.ok( callCount === 2, "two events, two calls" );
+			assert.ok( callCount === 2, 'two events, two calls' );
 
 		} );
 

test/unit/src/core/InstancedBufferAttribute.tests.js

@@ -7,38 +7,38 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'InstancedBufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.test( "Instancing", ( assert ) => {
+		QUnit.test( 'Instancing', ( assert ) => {
 
 			var instance = new InstancedBufferAttribute( new Float32Array( 10 ), 2 );
-			assert.ok( instance.meshPerAttribute === 1, "ok" );
+			assert.ok( instance.meshPerAttribute === 1, 'ok' );
 
 			var instance = new InstancedBufferAttribute( new Float32Array( 10 ), 2, false, 123 );
-			assert.ok( instance.meshPerAttribute === 123, "ok" );
+			assert.ok( instance.meshPerAttribute === 123, 'ok' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.test( "copy", ( assert ) => {
+		QUnit.test( 'copy', ( assert ) => {
 
 			var array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
 			var instance = new InstancedBufferAttribute( array, 2, true, 123 );
 			var copiedInstance = instance.copy( instance );
 
-			assert.ok( copiedInstance instanceof InstancedBufferAttribute, "the clone has the correct type" );
-			assert.ok( copiedInstance.itemSize === 2, "itemSize was copied" );
-			assert.ok( copiedInstance.normalized === true, "normalized was copied" );
-			assert.ok( copiedInstance.meshPerAttribute === 123, "meshPerAttribute was copied" );
+			assert.ok( copiedInstance instanceof InstancedBufferAttribute, 'the clone has the correct type' );
+			assert.ok( copiedInstance.itemSize === 2, 'itemSize was copied' );
+			assert.ok( copiedInstance.normalized === true, 'normalized was copied' );
+			assert.ok( copiedInstance.meshPerAttribute === 123, 'meshPerAttribute was copied' );
 
 			for ( var i = 0; i < array.length; i ++ ) {
 
-				assert.ok( copiedInstance.array[ i ] === array[ i ], "array was copied" );
+				assert.ok( copiedInstance.array[ i ] === array[ i ], 'array was copied' );
 
 			}
 

test/unit/src/core/InstancedBufferGeometry.tests.js

@@ -22,21 +22,21 @@ export default QUnit.module( 'Core', () => {
 		}
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.test( "copy", ( assert ) => {
+		QUnit.test( 'copy', ( assert ) => {
 
 			var instanceMock1 = {};
 			var instanceMock2 = {};
@@ -54,28 +54,28 @@ export default QUnit.module( 'Core', () => {
 
 			var copiedInstance = new InstancedBufferGeometry().copy( instance );
 
-			assert.ok( copiedInstance instanceof InstancedBufferGeometry, "the clone has the correct type" );
+			assert.ok( copiedInstance instanceof InstancedBufferGeometry, 'the clone has the correct type' );
 
-			assert.equal( copiedInstance.index, indexMock, "index was copied" );
-			assert.equal( copiedInstance.index.callCount, 1, "index.clone was called once" );
+			assert.equal( copiedInstance.index, indexMock, 'index was copied' );
+			assert.equal( copiedInstance.index.callCount, 1, 'index.clone was called once' );
 
-			assert.ok( copiedInstance.attributes[ 'defaultAttribute1' ] instanceof BufferAttribute, "attribute was created" );
-			assert.deepEqual( copiedInstance.attributes[ 'defaultAttribute1' ].array, defaultAttribute1.array, "attribute was copied" );
-			assert.deepEqual( copiedInstance.attributes[ 'defaultAttribute2' ].array, defaultAttribute2.array, "attribute was copied" );
+			assert.ok( copiedInstance.attributes[ 'defaultAttribute1' ] instanceof BufferAttribute, 'attribute was created' );
+			assert.deepEqual( copiedInstance.attributes[ 'defaultAttribute1' ].array, defaultAttribute1.array, 'attribute was copied' );
+			assert.deepEqual( copiedInstance.attributes[ 'defaultAttribute2' ].array, defaultAttribute2.array, 'attribute was copied' );
 
-			assert.equal( copiedInstance.groups[ 0 ].start, 0, "group was copied" );
-			assert.equal( copiedInstance.groups[ 0 ].count, 10, "group was copied" );
-			assert.equal( copiedInstance.groups[ 0 ].materialIndex, instanceMock1, "group was copied" );
+			assert.equal( copiedInstance.groups[ 0 ].start, 0, 'group was copied' );
+			assert.equal( copiedInstance.groups[ 0 ].count, 10, 'group was copied' );
+			assert.equal( copiedInstance.groups[ 0 ].materialIndex, instanceMock1, 'group was copied' );
 
-			assert.equal( copiedInstance.groups[ 1 ].start, 10, "group was copied" );
-			assert.equal( copiedInstance.groups[ 1 ].count, 5, "group was copied" );
-			assert.equal( copiedInstance.groups[ 1 ].materialIndex, instanceMock2, "group was copied" );
+			assert.equal( copiedInstance.groups[ 1 ].start, 10, 'group was copied' );
+			assert.equal( copiedInstance.groups[ 1 ].count, 5, 'group was copied' );
+			assert.equal( copiedInstance.groups[ 1 ].materialIndex, instanceMock2, 'group was copied' );
 
 		} );
 
-		QUnit.todo( "clone", ( assert ) => {
+		QUnit.todo( 'clone', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/core/InstancedInterleavedBuffer.tests.js

@@ -7,36 +7,36 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'InstancedInterleavedBuffer', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.test( "Instancing", ( assert ) => {
+		QUnit.test( 'Instancing', ( assert ) => {
 
 			var array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
 			var instance = new InstancedInterleavedBuffer( array, 3 );
 
-			assert.ok( instance.meshPerAttribute === 1, "ok" );
+			assert.ok( instance.meshPerAttribute === 1, 'ok' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isInstancedInterleavedBuffer", ( assert ) => {
+		QUnit.todo( 'isInstancedInterleavedBuffer', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "copy", ( assert ) => {
+		QUnit.test( 'copy', ( assert ) => {
 
 			var array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
 			var instance = new InstancedInterleavedBuffer( array, 3 );
 			var copiedInstance = instance.copy( instance );
 
-			assert.ok( copiedInstance.meshPerAttribute === 1, "additional attribute was copied" );
+			assert.ok( copiedInstance.meshPerAttribute === 1, 'additional attribute was copied' );
 
 		} );
 

test/unit/src/core/InterleavedBuffer.tests.js

@@ -9,54 +9,54 @@ export default QUnit.module( 'Core', () => {
 
 		function checkInstanceAgainstCopy( instance, copiedInstance, assert ) {
 
-			assert.ok( copiedInstance instanceof InterleavedBuffer, "the clone has the correct type" );
+			assert.ok( copiedInstance instanceof InterleavedBuffer, 'the clone has the correct type' );
 
 			for ( var i = 0; i < instance.array.length; i ++ ) {
 
-				assert.ok( copiedInstance.array[ i ] === instance.array[ i ], "array was copied" );
+				assert.ok( copiedInstance.array[ i ] === instance.array[ i ], 'array was copied' );
 
 			}
 
-			assert.ok( copiedInstance.stride === instance.stride, "stride was copied" );
-			assert.ok( copiedInstance.usage === DynamicDrawUsage, "usage was copied" );
+			assert.ok( copiedInstance.stride === instance.stride, 'stride was copied' );
+			assert.ok( copiedInstance.usage === DynamicDrawUsage, 'usage was copied' );
 
 		}
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PROPERTIES
-		QUnit.test( "needsUpdate", ( assert ) => {
+		QUnit.test( 'needsUpdate', ( assert ) => {
 
 			var a = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 4 ] ), 2 );
 
 			a.needsUpdate = true;
 
-			assert.strictEqual( a.version, 1, "Check version increased" );
+			assert.strictEqual( a.version, 1, 'Check version increased' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isInterleavedBuffer", ( assert ) => {
+		QUnit.todo( 'isInterleavedBuffer', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.test( "setUsage", ( assert ) => {
+		QUnit.test( 'setUsage', ( assert ) => {
 
 			var instance = new InterleavedBuffer();
 			instance.setUsage( DynamicDrawUsage );
 
-			assert.strictEqual( instance.usage, DynamicDrawUsage, "Usage was set" );
+			assert.strictEqual( instance.usage, DynamicDrawUsage, 'Usage was set' );
 
 		} );
 
-		QUnit.test( "copy", ( assert ) => {
+		QUnit.test( 'copy', ( assert ) => {
 
 			var array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
 			var instance = new InterleavedBuffer( array, 3 );
@@ -66,7 +66,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyAt", ( assert ) => {
+		QUnit.test( 'copyAt', ( assert ) => {
 
 			var a = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ), 3 );
 			var b = new InterleavedBuffer( new Float32Array( 9 ), 3 );
@@ -76,36 +76,36 @@ export default QUnit.module( 'Core', () => {
 			b.copyAt( 0, a, 1 );
 			b.copyAt( 2, a, 0 );
 
-			assert.deepEqual( b.array, expected, "Check the right values were replaced" );
+			assert.deepEqual( b.array, expected, 'Check the right values were replaced' );
 
 		} );
 
-		QUnit.test( "set", ( assert ) => {
+		QUnit.test( 'set', ( assert ) => {
 
 			var instance = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
 
 			instance.set( [ 0, - 1 ] );
-			assert.ok( instance.array[ 0 ] === 0 && instance.array[ 1 ] === - 1, "replace at first by default" );
+			assert.ok( instance.array[ 0 ] === 0 && instance.array[ 1 ] === - 1, 'replace at first by default' );
 
 		} );
 
-		QUnit.test( "onUpload", ( assert ) => {
+		QUnit.test( 'onUpload', ( assert ) => {
 
 			var a = new InterleavedBuffer();
 			var func = function () { };
 
 			a.onUpload( func );
 
-			assert.strictEqual( a.onUploadCallback, func, "Check callback was set properly" );
+			assert.strictEqual( a.onUploadCallback, func, 'Check callback was set properly' );
 
 		} );
 
 		// OTHERS
-		QUnit.test( "count", ( assert ) => {
+		QUnit.test( 'count', ( assert ) => {
 
 			var instance = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
 
-			assert.equal( instance.count, 2, "count is calculated via array length / stride" );
+			assert.equal( instance.count, 2, 'count is calculated via array length / stride' );
 
 		} );
 

test/unit/src/core/InterleavedBufferAttribute.tests.js

@@ -8,32 +8,32 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'InterleavedBufferAttribute', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PROPERTIES
-		QUnit.test( "count", ( assert ) => {
+		QUnit.test( 'count', ( assert ) => {
 
 			var buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
 			var instance = new InterleavedBufferAttribute( buffer, 2, 0 );
 
-			assert.ok( instance.count === 2, "count is calculated via array length / stride" );
+			assert.ok( instance.count === 2, 'count is calculated via array length / stride' );
 
 		} );
 
-		QUnit.todo( "array", ( assert ) => {
+		QUnit.todo( 'array', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
 		// setY, setZ and setW are calculated in the same way so not QUnit.testing this
 		// TODO: ( you can't be sure that will be the case in future, or a mistake was introduce in one off them ! )
-		QUnit.test( "setX", ( assert ) => {
+		QUnit.test( 'setX', ( assert ) => {
 
 			var buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
 			var instance = new InterleavedBufferAttribute( buffer, 2, 0 );
@@ -42,7 +42,7 @@ export default QUnit.module( 'Core', () => {
 			instance.setX( 1, 321 );
 
 			assert.ok( instance.data.array[ 0 ] === 123 &&
-				instance.data.array[ 3 ] === 321, "x was calculated correct based on index and default offset" );
+				instance.data.array[ 3 ] === 321, 'x was calculated correct based on index and default offset' );
 
 			var buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
 			var instance = new InterleavedBufferAttribute( buffer, 2, 1 );
@@ -52,67 +52,67 @@ export default QUnit.module( 'Core', () => {
 
 			// the offset was defined as 1, so go one step futher in the array
 			assert.ok( instance.data.array[ 1 ] === 123 &&
-				instance.data.array[ 4 ] === 321, "x was calculated correct based on index and default offset" );
+				instance.data.array[ 4 ] === 321, 'x was calculated correct based on index and default offset' );
 
 		} );
 
-		QUnit.todo( "setY", ( assert ) => {
+		QUnit.todo( 'setY', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setZ", ( assert ) => {
+		QUnit.todo( 'setZ', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setW", ( assert ) => {
+		QUnit.todo( 'setW', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getX", ( assert ) => {
+		QUnit.todo( 'getX', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getY", ( assert ) => {
+		QUnit.todo( 'getY', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getZ", ( assert ) => {
+		QUnit.todo( 'getZ', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "getW", ( assert ) => {
+		QUnit.todo( 'getW', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setXY", ( assert ) => {
+		QUnit.todo( 'setXY', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setXYZ", ( assert ) => {
+		QUnit.todo( 'setXYZ', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setXYZW", ( assert ) => {
+		QUnit.todo( 'setXYZW', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/core/Raycaster.tests.js

@@ -12,8 +12,8 @@ import { OrthographicCamera } from '../../../../src/cameras/OrthographicCamera';
 
 function checkRayDirectionAgainstReferenceVector( rayDirection, refVector, assert ) {
 
-	assert.ok( refVector.x - rayDirection.x <= Number.EPSILON && refVector.y - rayDirection.y <= Number.EPSILON && refVector.z - rayDirection.z <= Number.EPSILON, "camera is pointing to" +
-		" the same direction as expected" );
+	assert.ok( refVector.x - rayDirection.x <= Number.EPSILON && refVector.y - rayDirection.y <= Number.EPSILON && refVector.z - rayDirection.z <= Number.EPSILON, 'camera is pointing to' +
+		' the same direction as expected' );
 
 }
 
@@ -73,32 +73,32 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Raycaster', () => {
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.test( "set", ( assert ) => {
+		QUnit.test( 'set', ( assert ) => {
 
 			var origin = new Vector3( 0, 0, 0 );
 			var direction = new Vector3( 0, 0, - 1 );
 			var a = new Raycaster( origin.clone(), direction.clone() );
 
-			assert.deepEqual( a.ray.origin, origin, "Origin is correct" );
-			assert.deepEqual( a.ray.direction, direction, "Direction is correct" );
+			assert.deepEqual( a.ray.origin, origin, 'Origin is correct' );
+			assert.deepEqual( a.ray.direction, direction, 'Direction is correct' );
 
 			origin.set( 1, 1, 1 );
 			direction.set( - 1, 0, 0 );
 			a.set( origin, direction );
 
-			assert.deepEqual( a.ray.origin, origin, "Origin was set correctly" );
-			assert.deepEqual( a.ray.direction, direction, "Direction was set correctly" );
+			assert.deepEqual( a.ray.origin, origin, 'Origin was set correctly' );
+			assert.deepEqual( a.ray.direction, direction, 'Direction was set correctly' );
 
 		} );
 
-		QUnit.test( "setFromCamera (Perspective)", ( assert ) => {
+		QUnit.test( 'setFromCamera (Perspective)', ( assert ) => {
 
 			var raycaster = new Raycaster();
 			var rayDirection = raycaster.ray.direction;
@@ -109,7 +109,7 @@ export default QUnit.module( 'Core', () => {
 				y: 0
 			}, camera );
 			assert.ok( rayDirection.x === 0 && rayDirection.y === 0 && rayDirection.z === - 1,
-				"camera is looking straight to -z and so does the ray in the middle of the screen" );
+				'camera is looking straight to -z and so does the ray in the middle of the screen' );
 
 			var step = 0.1;
 
@@ -132,7 +132,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "setFromCamera (Orthographic)", ( assert ) => {
+		QUnit.test( 'setFromCamera (Orthographic)', ( assert ) => {
 
 			var raycaster = new Raycaster();
 			var rayOrigin = raycaster.ray.origin;
@@ -145,82 +145,82 @@ export default QUnit.module( 'Core', () => {
 				x: 0,
 				y: 0
 			}, camera );
-			assert.deepEqual( rayOrigin, expectedOrigin, "Ray origin has the right coordinates" );
-			assert.deepEqual( rayDirection, expectedDirection, "Camera and Ray are pointing towards -z" );
+			assert.deepEqual( rayOrigin, expectedOrigin, 'Ray origin has the right coordinates' );
+			assert.deepEqual( rayDirection, expectedDirection, 'Camera and Ray are pointing towards -z' );
 
 		} );
 
-		QUnit.test( "intersectObject", ( assert ) => {
+		QUnit.test( 'intersectObject', ( assert ) => {
 
 			var raycaster = getRaycaster();
 			var objectsToCheck = getObjectsToCheck();
 
 			assert.ok( raycaster.intersectObject( objectsToCheck[ 0 ], false ).length === 1,
-				"no recursive search should lead to one hit" );
+				'no recursive search should lead to one hit' );
 
 			assert.ok( raycaster.intersectObject( objectsToCheck[ 0 ] ).length === 3,
-				"recursive search should lead to three hits" );
+				'recursive search should lead to three hits' );
 
 			var intersections = raycaster.intersectObject( objectsToCheck[ 0 ] );
 			for ( var i = 0; i < intersections.length - 1; i ++ ) {
 
-				assert.ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, "intersections are sorted" );
+				assert.ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, 'intersections are sorted' );
 
 			}
 
 		} );
 
-		QUnit.test( "intersectObjects", ( assert ) => {
+		QUnit.test( 'intersectObjects', ( assert ) => {
 
 			var raycaster = getRaycaster();
 			var objectsToCheck = getObjectsToCheck();
 
 			assert.ok( raycaster.intersectObjects( objectsToCheck, false ).length === 1,
-				"no recursive search should lead to one hit" );
+				'no recursive search should lead to one hit' );
 
 			assert.ok( raycaster.intersectObjects( objectsToCheck ).length === 3,
-				"recursive search should lead to three hits" );
+				'recursive search should lead to three hits' );
 
 			var intersections = raycaster.intersectObjects( objectsToCheck );
 			for ( var i = 0; i < intersections.length - 1; i ++ ) {
 
-				assert.ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, "intersections are sorted" );
+				assert.ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, 'intersections are sorted' );
 
 			}
 
 		} );
 
-		QUnit.test( "Line intersection threshold", ( assert ) => {
+		QUnit.test( 'Line intersection threshold', ( assert ) => {
 
 			var raycaster = getRaycaster();
-			var points = [ new Vector3( -2, -10, -5 ), new Vector3( -2, 10, -5 ) ];
+			var points = [ new Vector3( - 2, - 10, - 5 ), new Vector3( - 2, 10, - 5 ) ];
 			var geometry = new BufferGeometry().setFromPoints( points );
 			var line = new Line( geometry, null );
 
 			raycaster.params.Line.threshold = 1.999;
 			assert.ok( raycaster.intersectObject( line ).length === 0,
-				"no Line intersection with a not-large-enough threshold" );
+				'no Line intersection with a not-large-enough threshold' );
 
 			raycaster.params.Line.threshold = 2.001;
 			assert.ok( raycaster.intersectObject( line ).length === 1,
-				"successful Line intersection with a large-enough threshold" );
+				'successful Line intersection with a large-enough threshold' );
 
 		} );
 
-		QUnit.test( "Points intersection threshold", ( assert ) => {
+		QUnit.test( 'Points intersection threshold', ( assert ) => {
 
 			var raycaster = getRaycaster();
-			var coordinates = [ new Vector3( -2, 0, -5 ) ];
+			var coordinates = [ new Vector3( - 2, 0, - 5 ) ];
 			var geometry = new BufferGeometry().setFromPoints( coordinates );
 			var points = new Points( geometry, null );
 
 			raycaster.params.Points.threshold = 1.999;
 			assert.ok( raycaster.intersectObject( points ).length === 0,
-				"no Points intersection with a not-large-enough threshold" );
+				'no Points intersection with a not-large-enough threshold' );
 
 			raycaster.params.Points.threshold = 2.001;
 			assert.ok( raycaster.intersectObject( points ).length === 1,
-				"successful Points intersection with a large-enough threshold" );
+				'successful Points intersection with a large-enough threshold' );
 
 		} );
 

test/unit/src/core/Uniform.tests.js

@@ -13,31 +13,31 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uniform', () => {
 
 		// INSTANCING
-		QUnit.test( "Instancing", ( assert ) => {
+		QUnit.test( 'Instancing', ( assert ) => {
 
 			var a;
 			var b = new Vector3( x, y, z );
 
 			a = new Uniform( 5 );
-			assert.strictEqual( a.value, 5, "New constructor works with simple values" );
+			assert.strictEqual( a.value, 5, 'New constructor works with simple values' );
 
 			a = new Uniform( b );
-			assert.ok( a.value.equals( b ), "New constructor works with complex values" );
+			assert.ok( a.value.equals( b ), 'New constructor works with complex values' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.test( "clone", ( assert ) => {
+		QUnit.test( 'clone', ( assert ) => {
 
 			var a = new Uniform( 23 );
 			var b = a.clone();
 
-			assert.strictEqual( b.value, a.value, "clone() with simple values works" );
+			assert.strictEqual( b.value, a.value, 'clone() with simple values works' );
 
 			var a = new Uniform( new Vector3( 1, 2, 3 ) );
 			var b = a.clone();
 
-			assert.ok( b.value.equals( a.value ), "clone() with complex values works" );
+			assert.ok( b.value.equals( a.value ), 'clone() with complex values works' );
 
 		} );
 

test/unit/src/extras/ShapeUtils.tests.js

@@ -7,21 +7,21 @@ export default QUnit.module( 'Extras', () => {
 	QUnit.module( 'ShapeUtils', () => {
 
 		// PUBLIC STUFF
-		QUnit.todo( "area", ( assert ) => {
+		QUnit.todo( 'area', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "isClockWise", ( assert ) => {
+		QUnit.todo( 'isClockWise', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "triangulateShape", ( assert ) => {
+		QUnit.todo( 'triangulateShape', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/extras/core/Curve.tests.js

@@ -9,76 +9,76 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'Curve', () => {
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPointAt", ( assert ) => {
+			QUnit.todo( 'getPointAt', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoints", ( assert ) => {
+			QUnit.todo( 'getPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getSpacedPoints", ( assert ) => {
+			QUnit.todo( 'getSpacedPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getLength", ( assert ) => {
+			QUnit.todo( 'getLength', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getLengths", ( assert ) => {
+			QUnit.todo( 'getLengths', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "updateArcLengths", ( assert ) => {
+			QUnit.todo( 'updateArcLengths', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getUtoTmapping", ( assert ) => {
+			QUnit.todo( 'getUtoTmapping', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getTangent", ( assert ) => {
+			QUnit.todo( 'getTangent', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getTangentAt", ( assert ) => {
+			QUnit.todo( 'getTangentAt', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "computeFrenetFrames", ( assert ) => {
+			QUnit.todo( 'computeFrenetFrames', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/core/CurvePath.tests.js

@@ -9,83 +9,83 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'CurvePath', () => {
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "add", ( assert ) => {
+			QUnit.todo( 'add', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "closePath", ( assert ) => {
+			QUnit.todo( 'closePath', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getLength", ( assert ) => {
+			QUnit.todo( 'getLength', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "updateArcLengths", ( assert ) => {
+			QUnit.todo( 'updateArcLengths', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getCurveLengths", ( assert ) => {
+			QUnit.todo( 'getCurveLengths', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getSpacedPoints", ( assert ) => {
+			QUnit.todo( 'getSpacedPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoints", ( assert ) => {
+			QUnit.todo( 'getPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "createPointsGeometry", ( assert ) => {
+			QUnit.todo( 'createPointsGeometry', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "createSpacedPointsGeometry", ( assert ) => {
+			QUnit.todo( 'createSpacedPointsGeometry', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "createGeometry", ( assert ) => {
+			QUnit.todo( 'createGeometry', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/core/Interpolations.tests.js

@@ -9,21 +9,21 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'Interpolations', () => {
 
 			// PUBLIC STUFF
-			QUnit.todo( "CatmullRom", ( assert ) => {
+			QUnit.todo( 'CatmullRom', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "QuadraticBezier", ( assert ) => {
+			QUnit.todo( 'QuadraticBezier', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "CubicBezier", ( assert ) => {
+			QUnit.todo( 'CubicBezier', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/core/Path.tests.js

@@ -9,77 +9,77 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'Path', () => {
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "fromPoints", ( assert ) => {
+			QUnit.todo( 'fromPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "moveTo", ( assert ) => {
+			QUnit.todo( 'moveTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "lineTo", ( assert ) => {
+			QUnit.todo( 'lineTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "quadraticCurveTo", ( assert ) => {
+			QUnit.todo( 'quadraticCurveTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "bezierCurveTo", ( assert ) => {
+			QUnit.todo( 'bezierCurveTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "splineThru", ( assert ) => {
+			QUnit.todo( 'splineThru', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "arc", ( assert ) => {
+			QUnit.todo( 'arc', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "absarc", ( assert ) => {
+			QUnit.todo( 'absarc', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "ellipse", ( assert ) => {
+			QUnit.todo( 'ellipse', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "absellipse", ( assert ) => {
+			QUnit.todo( 'absellipse', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/core/Shape.tests.js

@@ -9,35 +9,35 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'Shape', () => {
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "getPointsHoles", ( assert ) => {
+			QUnit.todo( 'getPointsHoles', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "extractAllPoints", ( assert ) => {
+			QUnit.todo( 'extractAllPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "extractPoints", ( assert ) => {
+			QUnit.todo( 'extractPoints', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/core/ShapePath.tests.js

@@ -9,46 +9,46 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'ShapePath', () => {
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "moveTo", ( assert ) => {
+			QUnit.todo( 'moveTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "lineTo", ( assert ) => {
+			QUnit.todo( 'lineTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "quadraticCurveTo", ( assert ) => {
+			QUnit.todo( 'quadraticCurveTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "bezierCurveTo", ( assert ) => {
+			QUnit.todo( 'bezierCurveTo', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "splineThru", ( assert ) => {
+			QUnit.todo( 'splineThru', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "toShapes", ( assert ) => {
+			QUnit.todo( 'toShapes', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/curves/ArcCurve.tests.js

@@ -9,23 +9,23 @@ export default QUnit.module( 'Extras', () => {
 		QUnit.module( 'ArcCurve', () => {
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isArcCurve", ( assert ) => {
+			QUnit.todo( 'isArcCurve', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 

test/unit/src/extras/curves/CatmullRomCurve3.tests.js

@@ -20,34 +20,34 @@ export default QUnit.module( 'Extras', () => {
 			/* eslint-enable */
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isCatmullRomCurve3", ( assert ) => {
+			QUnit.todo( 'isCatmullRomCurve3', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "catmullrom check", ( assert ) => {
+			QUnit.test( 'catmullrom check', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -82,7 +82,7 @@ export default QUnit.module( 'Extras', () => {
 
 			} );
 
-			QUnit.test( "chordal basic check", ( assert ) => {
+			QUnit.test( 'chordal basic check', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 
@@ -116,7 +116,7 @@ export default QUnit.module( 'Extras', () => {
 
 			} );
 
-			QUnit.test( "centripetal basic check", ( assert ) => {
+			QUnit.test( 'centripetal basic check', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'centripetal';
@@ -149,7 +149,7 @@ export default QUnit.module( 'Extras', () => {
 
 			} );
 
-			QUnit.test( "closed catmullrom basic check", ( assert ) => {
+			QUnit.test( 'closed catmullrom basic check', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -186,7 +186,7 @@ export default QUnit.module( 'Extras', () => {
 			//
 			// curve.type = 'catmullrom'; only from here on
 			//
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -194,7 +194,7 @@ export default QUnit.module( 'Extras', () => {
 				var length = curve.getLength();
 				var expectedLength = 551.549686276872;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var expectedLengths = [
 					0,
@@ -205,17 +205,17 @@ export default QUnit.module( 'Extras', () => {
 				];
 				var lengths = curve.getLengths( expectedLengths.length - 1 );
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -234,11 +234,11 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector3() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct points" );
+				assert.deepEqual( points, expectedPoints, 'Correct points' );
 
 			} );
 
-			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
+			QUnit.test( 'getTangent/getTangentAt', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -263,8 +263,8 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangent #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangent #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangent #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangent #' + i + ': y correct' );
 
 				} );
 
@@ -290,14 +290,14 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangentAt #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangentAt #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangentAt #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangentAt #' + i + ': y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "computeFrenetFrames", ( assert ) => {
+			QUnit.test( 'computeFrenetFrames', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -326,9 +326,9 @@ export default QUnit.module( 'Extras', () => {
 
 					expected[ group ].forEach( function ( vec, j ) {
 
-						assert.numEqual( frames[ group ][ j ].x, vec.x, "Frenet frames [" + i + ", " + j + "].x correct" );
-						assert.numEqual( frames[ group ][ j ].y, vec.y, "Frenet frames [" + i + ", " + j + "].y correct" );
-						assert.numEqual( frames[ group ][ j ].z, vec.z, "Frenet frames [" + i + ", " + j + "].z correct" );
+						assert.numEqual( frames[ group ][ j ].x, vec.x, 'Frenet frames [' + i + ', ' + j + '].x correct' );
+						assert.numEqual( frames[ group ][ j ].y, vec.y, 'Frenet frames [' + i + ', ' + j + '].y correct' );
+						assert.numEqual( frames[ group ][ j ].z, vec.z, 'Frenet frames [' + i + ', ' + j + '].z correct' );
 
 					} );
 
@@ -336,7 +336,7 @@ export default QUnit.module( 'Extras', () => {
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -347,13 +347,13 @@ export default QUnit.module( 'Extras', () => {
 
 				var expectedSomewhere = 0.8964116382083199;
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, expectedSomewhere, "getUtoTmapping( 0.5, 500 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, expectedSomewhere, 'getUtoTmapping( 0.5, 500 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
 				curve.curveType = 'catmullrom';
@@ -369,8 +369,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints();
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 

test/unit/src/extras/curves/CubicBezierCurve.tests.js

@@ -22,34 +22,34 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isCubicBezierCurve", ( assert ) => {
+			QUnit.todo( 'isCubicBezierCurve', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector2( - 10, 0 ),
@@ -61,8 +61,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 				// symmetry
 				var curveRev = new CubicBezierCurve(
@@ -71,17 +71,17 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curveRev.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Reversed: Correct number of points" );
-				assert.deepEqual( points, expectedPoints.reverse(), "Reversed: Correct points curve" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Reversed: Correct number of points' );
+				assert.deepEqual( points, expectedPoints.reverse(), 'Reversed: Correct points curve' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var length = curve.getLength();
 				var expectedLength = 36.64630888504102;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var expectedLengths = [
 					0,
@@ -92,17 +92,17 @@ export default QUnit.module( 'Extras', () => {
 				];
 				var lengths = curve.getLengths( expectedLengths.length - 1 );
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector2( - 10, 0 ),
@@ -118,11 +118,11 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector2() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct points" );
+				assert.deepEqual( points, expectedPoints, 'Correct points' );
 
 			} );
 
-			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
+			QUnit.test( 'getTangent/getTangentAt', ( assert ) => {
 
 				var expectedTangents = [
 					new Vector2( 0.316370061632252, 0.9486358543207215 ),
@@ -144,8 +144,8 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangent #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangent #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangent #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangent #' + i + ': y correct' );
 
 				} );
 
@@ -171,14 +171,14 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangentAt #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangentAt #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangentAt #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangentAt #' + i + ': y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var start = curve.getUtoTmapping( 0, 0 );
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
@@ -186,13 +186,13 @@ export default QUnit.module( 'Extras', () => {
 
 				var expectedSomewhere = 0.02130029182257093;
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, expectedSomewhere, "getUtoTmapping( 0.5, 1 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, expectedSomewhere, 'getUtoTmapping( 0.5, 1 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector2( - 10, 0 ),
@@ -205,8 +205,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints();
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 

test/unit/src/extras/curves/CubicBezierCurve3.tests.js

@@ -22,34 +22,34 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isCubicBezierCurve3", ( assert ) => {
+			QUnit.todo( 'isCubicBezierCurve3', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector3( - 10, 0, 2 ),
@@ -61,8 +61,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 				// symmetry
 				var curveRev = new CubicBezierCurve3(
@@ -71,17 +71,17 @@ export default QUnit.module( 'Extras', () => {
 
 				points = curveRev.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Reversed: Correct number of points" );
-				assert.deepEqual( points, expectedPoints.reverse(), "Reversed: Correct points curve" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Reversed: Correct number of points' );
+				assert.deepEqual( points, expectedPoints.reverse(), 'Reversed: Correct points curve' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var length = curve.getLength();
 				var expectedLength = 39.58103024989427;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var expectedLengths = [
 					0,
@@ -92,17 +92,17 @@ export default QUnit.module( 'Extras', () => {
 				];
 				var lengths = curve.getLengths( expectedLengths.length - 1 );
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector3( - 10, 0, 2 ),
@@ -118,11 +118,11 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector3() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct points" );
+				assert.deepEqual( points, expectedPoints, 'Correct points' );
 
 			} );
 
-			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
+			QUnit.test( 'getTangent/getTangentAt', ( assert ) => {
 
 				var expectedTangents = [
 					new Vector3( 0.3138715439944244, 0.9411440474105875, 0.12542940601858074 ),
@@ -144,8 +144,8 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangent #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangent #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangent #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangent #' + i + ': y correct' );
 
 				} );
 
@@ -171,14 +171,14 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangentAt #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangentAt #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangentAt #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangentAt #' + i + ': y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var start = curve.getUtoTmapping( 0, 0 );
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
@@ -186,13 +186,13 @@ export default QUnit.module( 'Extras', () => {
 
 				var expectedSomewhere = 0.021163245321323316;
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, expectedSomewhere, "getUtoTmapping( 0.5, 1 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, expectedSomewhere, 'getUtoTmapping( 0.5, 1 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector3( - 10, 0, 2 ),
@@ -205,12 +205,12 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints();
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 
-			QUnit.test( "computeFrenetFrames", ( assert ) => {
+			QUnit.test( 'computeFrenetFrames', ( assert ) => {
 
 				var expected = {
 					binormals: [
@@ -236,9 +236,9 @@ export default QUnit.module( 'Extras', () => {
 
 					expected[ group ].forEach( function ( vec, j ) {
 
-						assert.numEqual( frames[ group ][ j ].x, vec.x, "Frenet frames [" + i + ", " + j + "].x correct" );
-						assert.numEqual( frames[ group ][ j ].y, vec.y, "Frenet frames [" + i + ", " + j + "].y correct" );
-						assert.numEqual( frames[ group ][ j ].z, vec.z, "Frenet frames [" + i + ", " + j + "].z correct" );
+						assert.numEqual( frames[ group ][ j ].x, vec.x, 'Frenet frames [' + i + ', ' + j + '].x correct' );
+						assert.numEqual( frames[ group ][ j ].y, vec.y, 'Frenet frames [' + i + ', ' + j + '].y correct' );
+						assert.numEqual( frames[ group ][ j ].z, vec.z, 'Frenet frames [' + i + ', ' + j + '].z correct' );
 
 					} );
 

test/unit/src/extras/curves/EllipseCurve.tests.js

@@ -23,34 +23,34 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isEllipseCurve", ( assert ) => {
+			QUnit.todo( 'isEllipseCurve', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector2( 10, 0 ),
@@ -62,23 +62,23 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
 
 				points.forEach( function ( point, i ) {
 
-					assert.numEqual( point.x, expectedPoints[ i ].x, "point[" + i + "].x correct" );
-					assert.numEqual( point.y, expectedPoints[ i ].y, "point[" + i + "].y correct" );
+					assert.numEqual( point.x, expectedPoints[ i ].x, 'point[' + i + '].x correct' );
+					assert.numEqual( point.y, expectedPoints[ i ].y, 'point[' + i + '].y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var length = curve.getLength();
 				var expectedLength = 62.829269247282795;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var lengths = curve.getLengths( 5 );
 				var expectedLengths = [
@@ -90,17 +90,17 @@ export default QUnit.module( 'Extras', () => {
 					58.77852522924731
 				];
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getPoint/getPointAt", ( assert ) => {
+			QUnit.test( 'getPoint/getPointAt', ( assert ) => {
 
 				var testValues = [ 0, 0.3, 0.5, 0.7, 1 ];
 
@@ -115,17 +115,17 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPoint( val, p );
 					curve.getPointAt( val, a );
 
-					assert.numEqual( p.x, expectedX, "getPoint(" + val + ").x correct" );
-					assert.numEqual( p.y, expectedY, "getPoint(" + val + ").y correct" );
+					assert.numEqual( p.x, expectedX, 'getPoint(' + val + ').x correct' );
+					assert.numEqual( p.y, expectedY, 'getPoint(' + val + ').y correct' );
 
-					assert.numEqual( a.x, expectedX, "getPointAt(" + val + ").x correct" );
-					assert.numEqual( a.y, expectedY, "getPointAt(" + val + ").y correct" );
+					assert.numEqual( a.x, expectedX, 'getPointAt(' + val + ').x correct' );
+					assert.numEqual( a.y, expectedY, 'getPointAt(' + val + ').y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getTangent", ( assert ) => {
+			QUnit.test( 'getTangent', ( assert ) => {
 
 				var expectedTangents = [
 					new Vector2( - 0.000314159260186071, 0.9999999506519786 ),
@@ -147,14 +147,14 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangent #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangent #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangent #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangent #' + i + ': y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var start = curve.getUtoTmapping( 0, 0 );
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
@@ -162,13 +162,13 @@ export default QUnit.module( 'Extras', () => {
 
 				var expectedSomewhere = 0.01591614882650014;
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, expectedSomewhere, "getUtoTmapping( 0.7, 1 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, expectedSomewhere, 'getUtoTmapping( 0.7, 1 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var expectedPoints = [
 					new Vector2( 10, 0 ),
@@ -181,14 +181,14 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints();
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
 
 				expectedPoints.forEach( function ( exp, i ) {
 
 					var point = points[ i ];
 
-					assert.numEqual( point.x, exp.x, "Point #" + i + ": x correct" );
-					assert.numEqual( point.y, exp.y, "Point #" + i + ": y correct" );
+					assert.numEqual( point.x, exp.x, 'Point #' + i + ': x correct' );
+					assert.numEqual( point.y, exp.y, 'Point #' + i + ': y correct' );
 
 				} );
 

test/unit/src/extras/curves/LineCurve.tests.js

@@ -25,33 +25,33 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isLineCurve", ( assert ) => {
+			QUnit.todo( 'isLineCurve', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var curve = new LineCurve( _points[ 0 ], _points[ 3 ] );
 
@@ -69,11 +69,11 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector2() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct points" );
+				assert.deepEqual( points, expectedPoints, 'Correct points' );
 
 			} );
 
-			QUnit.test( "getTangent", ( assert ) => {
+			QUnit.test( 'getTangent', ( assert ) => {
 
 				var curve = _curve;
 				var tangent = new Vector2();
@@ -81,13 +81,13 @@ export default QUnit.module( 'Extras', () => {
 				curve.getTangent( 0, tangent );
 				var expectedTangent = Math.sqrt( 0.5 );
 
-				assert.numEqual( tangent.x, expectedTangent, "tangent.x correct" );
-				assert.numEqual( tangent.y, expectedTangent, "tangent.y correct" );
+				assert.numEqual( tangent.x, expectedTangent, 'tangent.x correct' );
+				assert.numEqual( tangent.y, expectedTangent, 'tangent.y correct' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var curve = _curve;
 
@@ -102,7 +102,7 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints();
 
-				assert.deepEqual( points, expectedPoints, "Correct points for first curve" );
+				assert.deepEqual( points, expectedPoints, 'Correct points for first curve' );
 
 				//
 
@@ -119,18 +119,18 @@ export default QUnit.module( 'Extras', () => {
 
 				points = curve.getPoints();
 
-				assert.deepEqual( points, expectedPoints, "Correct points for second curve" );
+				assert.deepEqual( points, expectedPoints, 'Correct points for second curve' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var curve = _curve;
 
 				var length = curve.getLength();
 				var expectedLength = Math.sqrt( 200 );
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var lengths = curve.getLengths( 5 );
 				var expectedLengths = [
@@ -142,17 +142,17 @@ export default QUnit.module( 'Extras', () => {
 					Math.sqrt( 200 )
 				];
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var curve = _curve;
 
@@ -160,13 +160,13 @@ export default QUnit.module( 'Extras', () => {
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
 				var somewhere = curve.getUtoTmapping( 0.3, 0 );
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, 0.3, "getUtoTmapping( 0.3, 0 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, 0.3, 'getUtoTmapping( 0.3, 0 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var curve = _curve;
 
@@ -180,8 +180,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints( 4 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 

test/unit/src/extras/curves/LineCurve3.tests.js

@@ -25,33 +25,33 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isCatmullRomCurve3", ( assert ) => {
+			QUnit.todo( 'isCatmullRomCurve3', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var curve = new LineCurve3( _points[ 0 ], _points[ 3 ] );
 
@@ -69,12 +69,12 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector3() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct getPointAt points" );
+				assert.deepEqual( points, expectedPoints, 'Correct getPointAt points' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var curve = _curve;
 
@@ -89,7 +89,7 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints();
 
-				assert.deepEqual( points, expectedPoints, "Correct points for first curve" );
+				assert.deepEqual( points, expectedPoints, 'Correct points for first curve' );
 
 				//
 
@@ -106,18 +106,18 @@ export default QUnit.module( 'Extras', () => {
 
 				points = curve.getPoints();
 
-				assert.deepEqual( points, expectedPoints, "Correct points for second curve" );
+				assert.deepEqual( points, expectedPoints, 'Correct points for second curve' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var curve = _curve;
 
 				var length = curve.getLength();
 				var expectedLength = Math.sqrt( 300 );
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var lengths = curve.getLengths( 5 );
 				var expectedLengths = [
@@ -129,17 +129,17 @@ export default QUnit.module( 'Extras', () => {
 					Math.sqrt( 300 )
 				];
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
+			QUnit.test( 'getTangent/getTangentAt', ( assert ) => {
 
 				var curve = _curve;
 				var tangent = new Vector3();
@@ -147,19 +147,19 @@ export default QUnit.module( 'Extras', () => {
 				curve.getTangent( 0.5, tangent );
 				var expectedTangent = Math.sqrt( 1 / 3 );
 
-				assert.numEqual( tangent.x, expectedTangent, "tangent.x correct" );
-				assert.numEqual( tangent.y, expectedTangent, "tangent.y correct" );
-				assert.numEqual( tangent.z, expectedTangent, "tangent.z correct" );
+				assert.numEqual( tangent.x, expectedTangent, 'tangent.x correct' );
+				assert.numEqual( tangent.y, expectedTangent, 'tangent.y correct' );
+				assert.numEqual( tangent.z, expectedTangent, 'tangent.z correct' );
 
 				tangent = curve.getTangentAt( 0.5 );
 
-				assert.numEqual( tangent.x, expectedTangent, "tangentAt.x correct" );
-				assert.numEqual( tangent.y, expectedTangent, "tangentAt.y correct" );
-				assert.numEqual( tangent.z, expectedTangent, "tangentAt.z correct" );
+				assert.numEqual( tangent.x, expectedTangent, 'tangentAt.x correct' );
+				assert.numEqual( tangent.y, expectedTangent, 'tangentAt.y correct' );
+				assert.numEqual( tangent.z, expectedTangent, 'tangentAt.z correct' );
 
 			} );
 
-			QUnit.test( "computeFrenetFrames", ( assert ) => {
+			QUnit.test( 'computeFrenetFrames', ( assert ) => {
 
 				var curve = _curve;
 
@@ -173,15 +173,15 @@ export default QUnit.module( 'Extras', () => {
 
 				for ( var val in expected ) {
 
-					assert.numEqual( frames[ val ][ 0 ].x, expected[ val ].x, "Frenet frames " + val + ".x correct" );
-					assert.numEqual( frames[ val ][ 0 ].y, expected[ val ].y, "Frenet frames " + val + ".y correct" );
-					assert.numEqual( frames[ val ][ 0 ].z, expected[ val ].z, "Frenet frames " + val + ".z correct" );
+					assert.numEqual( frames[ val ][ 0 ].x, expected[ val ].x, 'Frenet frames ' + val + '.x correct' );
+					assert.numEqual( frames[ val ][ 0 ].y, expected[ val ].y, 'Frenet frames ' + val + '.y correct' );
+					assert.numEqual( frames[ val ][ 0 ].z, expected[ val ].z, 'Frenet frames ' + val + '.z correct' );
 
 				}
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var curve = _curve;
 
@@ -189,13 +189,13 @@ export default QUnit.module( 'Extras', () => {
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
 				var somewhere = curve.getUtoTmapping( 0.7, 0 );
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, 0.7, "getUtoTmapping( 0.7, 0 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, 0.7, 'getUtoTmapping( 0.7, 0 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var curve = _curve;
 
@@ -209,8 +209,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints( 4 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 

test/unit/src/extras/curves/QuadraticBezierCurve.tests.js

@@ -21,34 +21,34 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isQuadraticBezierCurve", ( assert ) => {
+			QUnit.todo( 'isQuadraticBezierCurve', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var curve = _curve;
 
@@ -62,8 +62,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 				// symmetry
 				var curveRev = new QuadraticBezierCurve(
@@ -72,19 +72,19 @@ export default QUnit.module( 'Extras', () => {
 
 				points = curveRev.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Reversed: Correct number of points" );
-				assert.deepEqual( points, expectedPoints.reverse(), "Reversed: Correct points curve" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Reversed: Correct number of points' );
+				assert.deepEqual( points, expectedPoints.reverse(), 'Reversed: Correct points curve' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var curve = _curve;
 
 				var length = curve.getLength();
 				var expectedLength = 31.269026549416683;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var expectedLengths = [
 					0,
@@ -95,17 +95,17 @@ export default QUnit.module( 'Extras', () => {
 				];
 				var lengths = curve.getLengths( expectedLengths.length - 1 );
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var curve = _curve;
 
@@ -123,11 +123,11 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector2() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct points" );
+				assert.deepEqual( points, expectedPoints, 'Correct points' );
 
 			} );
 
-			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
+			QUnit.test( 'getTangent/getTangentAt', ( assert ) => {
 
 				var curve = _curve;
 
@@ -151,8 +151,8 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangent #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangent #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangent #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangent #' + i + ': y correct' );
 
 				} );
 
@@ -178,14 +178,14 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangentAt #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangentAt #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangentAt #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangentAt #' + i + ': y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var curve = _curve;
 
@@ -195,13 +195,13 @@ export default QUnit.module( 'Extras', () => {
 
 				var expectedSomewhere = 0.015073978276116116;
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, expectedSomewhere, "getUtoTmapping( 0.5, 1 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, expectedSomewhere, 'getUtoTmapping( 0.5, 1 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var curve = _curve;
 
@@ -216,8 +216,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints();
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 

test/unit/src/extras/curves/QuadraticBezierCurve3.tests.js

@@ -21,34 +21,34 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isQuadraticBezierCurve3", ( assert ) => {
+			QUnit.todo( 'isQuadraticBezierCurve3', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var curve = _curve;
 
@@ -62,8 +62,8 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 				// symmetry
 				var curveRev = new QuadraticBezierCurve3(
@@ -72,19 +72,19 @@ export default QUnit.module( 'Extras', () => {
 
 				points = curveRev.getPoints( expectedPoints.length - 1 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Reversed: Correct number of points" );
-				assert.deepEqual( points, expectedPoints.reverse(), "Reversed: Correct points curve" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Reversed: Correct number of points' );
+				assert.deepEqual( points, expectedPoints.reverse(), 'Reversed: Correct points curve' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var curve = _curve;
 
 				var length = curve.getLength();
 				var expectedLength = 35.47294274967861;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var expectedLengths = [
 					0,
@@ -95,17 +95,17 @@ export default QUnit.module( 'Extras', () => {
 				];
 				var lengths = curve.getLengths( expectedLengths.length - 1 );
 
-				assert.strictEqual( lengths.length, expectedLengths.length, "Correct number of segments" );
+				assert.strictEqual( lengths.length, expectedLengths.length, 'Correct number of segments' );
 
 				lengths.forEach( function ( segment, i ) {
 
-					assert.numEqual( segment, expectedLengths[ i ], "segment[" + i + "] correct" );
+					assert.numEqual( segment, expectedLengths[ i ], 'segment[' + i + '] correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var curve = _curve;
 
@@ -123,11 +123,11 @@ export default QUnit.module( 'Extras', () => {
 					curve.getPointAt( 1, new Vector3() )
 				];
 
-				assert.deepEqual( points, expectedPoints, "Correct points" );
+				assert.deepEqual( points, expectedPoints, 'Correct points' );
 
 			} );
 
-			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
+			QUnit.test( 'getTangent/getTangentAt', ( assert ) => {
 
 				var curve = _curve;
 
@@ -151,8 +151,8 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangent #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangent #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangent #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangent #' + i + ': y correct' );
 
 				} );
 
@@ -178,14 +178,14 @@ export default QUnit.module( 'Extras', () => {
 
 					var tangent = tangents[ i ];
 
-					assert.numEqual( tangent.x, exp.x, "getTangentAt #" + i + ": x correct" );
-					assert.numEqual( tangent.y, exp.y, "getTangentAt #" + i + ": y correct" );
+					assert.numEqual( tangent.x, exp.x, 'getTangentAt #' + i + ': x correct' );
+					assert.numEqual( tangent.y, exp.y, 'getTangentAt #' + i + ': y correct' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var curve = _curve;
 
@@ -195,13 +195,13 @@ export default QUnit.module( 'Extras', () => {
 
 				var expectedSomewhere = 0.014760890927167196;
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( somewhere, expectedSomewhere, "getUtoTmapping( 0.5, 1 ) is correct" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( somewhere, expectedSomewhere, 'getUtoTmapping( 0.5, 1 ) is correct' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var curve = _curve;
 
@@ -216,12 +216,12 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints();
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
-				assert.deepEqual( points, expectedPoints, "Correct points calculated" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
+				assert.deepEqual( points, expectedPoints, 'Correct points calculated' );
 
 			} );
 
-			QUnit.test( "computeFrenetFrames", ( assert ) => {
+			QUnit.test( 'computeFrenetFrames', ( assert ) => {
 
 				var curve = _curve;
 
@@ -249,9 +249,9 @@ export default QUnit.module( 'Extras', () => {
 
 					expected[ group ].forEach( function ( vec, j ) {
 
-						assert.numEqual( frames[ group ][ j ].x, vec.x, "Frenet frames [" + i + ", " + j + "].x correct" );
-						assert.numEqual( frames[ group ][ j ].y, vec.y, "Frenet frames [" + i + ", " + j + "].y correct" );
-						assert.numEqual( frames[ group ][ j ].z, vec.z, "Frenet frames [" + i + ", " + j + "].z correct" );
+						assert.numEqual( frames[ group ][ j ].x, vec.x, 'Frenet frames [' + i + ', ' + j + '].x correct' );
+						assert.numEqual( frames[ group ][ j ].y, vec.y, 'Frenet frames [' + i + ', ' + j + '].y correct' );
+						assert.numEqual( frames[ group ][ j ].z, vec.z, 'Frenet frames [' + i + ', ' + j + '].z correct' );
 
 					} );
 

test/unit/src/extras/curves/SplineCurve.tests.js

@@ -23,34 +23,34 @@ export default QUnit.module( 'Extras', () => {
 			} );
 
 			// INHERITANCE
-			QUnit.todo( "Extending", ( assert ) => {
+			QUnit.todo( 'Extending', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// INSTANCING
-			QUnit.todo( "Instancing", ( assert ) => {
+			QUnit.todo( 'Instancing', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// PUBLIC STUFF
-			QUnit.todo( "isSplineCurve", ( assert ) => {
+			QUnit.todo( 'isSplineCurve', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
-			QUnit.todo( "getPoint", ( assert ) => {
+			QUnit.todo( 'getPoint', ( assert ) => {
 
-				assert.ok( false, "everything's gonna be alright" );
+				assert.ok( false, 'everything\'s gonna be alright' );
 
 			} );
 
 			// OTHERS
-			QUnit.test( "Simple curve", ( assert ) => {
+			QUnit.test( 'Simple curve', ( assert ) => {
 
 				var curve = _curve;
 
@@ -65,12 +65,12 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getPoints( 5 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "1st: Correct number of points" );
+				assert.strictEqual( points.length, expectedPoints.length, '1st: Correct number of points' );
 
 				points.forEach( function ( point, i ) {
 
-					assert.numEqual( point.x, expectedPoints[ i ].x, "points[" + i + "].x" );
-					assert.numEqual( point.y, expectedPoints[ i ].y, "points[" + i + "].y" );
+					assert.numEqual( point.x, expectedPoints[ i ].x, 'points[' + i + '].x' );
+					assert.numEqual( point.y, expectedPoints[ i ].y, 'points[' + i + '].y' );
 
 				} );
 
@@ -78,18 +78,18 @@ export default QUnit.module( 'Extras', () => {
 
 				points = curve.getPoints( 4 );
 
-				assert.deepEqual( points, curve.points, "2nd: Returned points are identical to control points" );
+				assert.deepEqual( points, curve.points, '2nd: Returned points are identical to control points' );
 
 			} );
 
-			QUnit.test( "getLength/getLengths", ( assert ) => {
+			QUnit.test( 'getLength/getLengths', ( assert ) => {
 
 				var curve = _curve;
 
 				var length = curve.getLength();
 				var expectedLength = 28.876950901868135;
 
-				assert.numEqual( length, expectedLength, "Correct length of curve" );
+				assert.numEqual( length, expectedLength, 'Correct length of curve' );
 
 				var expectedLengths = [
 					0.0,
@@ -101,26 +101,26 @@ export default QUnit.module( 'Extras', () => {
 
 				var lengths = curve.getLengths( 4 );
 
-				assert.deepEqual( lengths, expectedLengths, "Correct segment lengths" );
+				assert.deepEqual( lengths, expectedLengths, 'Correct segment lengths' );
 
 			} );
 
-			QUnit.test( "getPointAt", ( assert ) => {
+			QUnit.test( 'getPointAt', ( assert ) => {
 
 				var curve = _curve;
 				var point = new Vector2();
 
-				assert.ok( curve.getPointAt( 0, point ).equals( curve.points[ 0 ] ), "PointAt 0.0 correct" );
-				assert.ok( curve.getPointAt( 1, point ).equals( curve.points[ 4 ] ), "PointAt 1.0 correct" );
+				assert.ok( curve.getPointAt( 0, point ).equals( curve.points[ 0 ] ), 'PointAt 0.0 correct' );
+				assert.ok( curve.getPointAt( 1, point ).equals( curve.points[ 4 ] ), 'PointAt 1.0 correct' );
 
 				curve.getPointAt( 0.5, point );
 
-				assert.numEqual( point.x, 0.0, "PointAt 0.5 x correct" );
-				assert.numEqual( point.y, 0.0, "PointAt 0.5 y correct" );
+				assert.numEqual( point.x, 0.0, 'PointAt 0.5 x correct' );
+				assert.numEqual( point.y, 0.0, 'PointAt 0.5 y correct' );
 
 			} );
 
-			QUnit.test( "getTangent", ( assert ) => {
+			QUnit.test( 'getTangent', ( assert ) => {
 
 				var curve = _curve;
 
@@ -138,14 +138,14 @@ export default QUnit.module( 'Extras', () => {
 
 				tangents.forEach( function ( tangent, i ) {
 
-					assert.numEqual( tangent.x, expectedTangent[ i ].x, "tangent[" + i + "].x" );
-					assert.numEqual( tangent.y, expectedTangent[ i ].y, "tangent[" + i + "].y" );
+					assert.numEqual( tangent.x, expectedTangent[ i ].x, 'tangent[' + i + '].x' );
+					assert.numEqual( tangent.y, expectedTangent[ i ].y, 'tangent[' + i + '].y' );
 
 				} );
 
 			} );
 
-			QUnit.test( "getUtoTmapping", ( assert ) => {
+			QUnit.test( 'getUtoTmapping', ( assert ) => {
 
 				var curve = _curve;
 
@@ -153,13 +153,13 @@ export default QUnit.module( 'Extras', () => {
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
 				var middle = curve.getUtoTmapping( 0.5, 0 );
 
-				assert.strictEqual( start, 0, "getUtoTmapping( 0, 0 ) is the starting point" );
-				assert.strictEqual( end, 1, "getUtoTmapping( 0, length ) is the ending point" );
-				assert.numEqual( middle, 0.5, "getUtoTmapping( 0.5, 0 ) is the middle" );
+				assert.strictEqual( start, 0, 'getUtoTmapping( 0, 0 ) is the starting point' );
+				assert.strictEqual( end, 1, 'getUtoTmapping( 0, length ) is the ending point' );
+				assert.numEqual( middle, 0.5, 'getUtoTmapping( 0.5, 0 ) is the middle' );
 
 			} );
 
-			QUnit.test( "getSpacedPoints", ( assert ) => {
+			QUnit.test( 'getSpacedPoints', ( assert ) => {
 
 				var curve = _curve;
 
@@ -173,12 +173,12 @@ export default QUnit.module( 'Extras', () => {
 
 				var points = curve.getSpacedPoints( 4 );
 
-				assert.strictEqual( points.length, expectedPoints.length, "Correct number of points" );
+				assert.strictEqual( points.length, expectedPoints.length, 'Correct number of points' );
 
 				points.forEach( function ( point, i ) {
 
-					assert.numEqual( point.x, expectedPoints[ i ].x, "points[" + i + "].x" );
-					assert.numEqual( point.y, expectedPoints[ i ].y, "points[" + i + "].y" );
+					assert.numEqual( point.x, expectedPoints[ i ].x, 'points[' + i + '].x' );
+					assert.numEqual( point.y, expectedPoints[ i ].y, 'points[' + i + '].y' );
 
 				} );
 

test/unit/src/geometries/BoxGeometry.tests.js

@@ -29,16 +29,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/CircleGeometry.tests.js

@@ -23,22 +23,22 @@ export default QUnit.module( 'Geometries', () => {
 				new CircleGeometry( parameters.radius, parameters.segments ),
 				new CircleGeometry( parameters.radius, parameters.segments, parameters.thetaStart ),
 				new CircleGeometry( parameters.radius, parameters.segments, parameters.thetaStart, parameters.thetaLength ),
-					new CircleBufferGeometry(),
+				new CircleBufferGeometry(),
 			];
 
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/ConeGeometry.tests.js

@@ -18,16 +18,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/CylinderGeometry.tests.js

@@ -37,16 +37,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/DodecahedronGeometry.tests.js

@@ -25,16 +25,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/EdgesGeometry.tests.js

@@ -26,11 +26,11 @@ function testEdges( vertList, idxList, numAfter, assert ) {
 		var geom = geoms[ i ];
 
 		var numBefore = idxList.length;
-		assert.equal( countEdges( geom ), numBefore, "Edges before!" );
+		assert.equal( countEdges( geom ), numBefore, 'Edges before!' );
 
 		var egeom = new EdgesGeometry( geom );
 
-		assert.equal( countEdges( egeom ), numAfter, "Edges after!" );
+		assert.equal( countEdges( egeom ), numAfter, 'Edges after!' );
 		output( geom, egeom );
 
 	}
@@ -213,39 +213,39 @@ export default QUnit.module( 'Geometries', () => {
 		];
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
-		QUnit.test( "singularity", ( assert ) => {
+		QUnit.test( 'singularity', ( assert ) => {
 
 			testEdges( vertList, [ 1, 1, 1 ], 0, assert );
 
 		} );
 
-		QUnit.test( "needle", ( assert ) => {
+		QUnit.test( 'needle', ( assert ) => {
 
 			testEdges( vertList, [ 0, 0, 1 ], 0, assert );
 
 		} );
 
-		QUnit.test( "single triangle", ( assert ) => {
+		QUnit.test( 'single triangle', ( assert ) => {
 
 			testEdges( vertList, [ 0, 1, 2 ], 3, assert );
 
 		} );
 
-		QUnit.test( "two isolated triangles", ( assert ) => {
+		QUnit.test( 'two isolated triangles', ( assert ) => {
 
 			var vertList = [
 				new Vector3( 0, 0, 0 ),
@@ -260,37 +260,37 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
-		QUnit.test( "two flat triangles", ( assert ) => {
+		QUnit.test( 'two flat triangles', ( assert ) => {
 
 			testEdges( vertList, [ 0, 1, 2, 0, 2, 3 ], 4, assert );
 
 		} );
 
-		QUnit.test( "two flat triangles, inverted", ( assert ) => {
+		QUnit.test( 'two flat triangles, inverted', ( assert ) => {
 
 			testEdges( vertList, [ 0, 1, 2, 0, 3, 2 ], 5, assert );
 
 		} );
 
-		QUnit.test( "two non-coplanar triangles", ( assert ) => {
+		QUnit.test( 'two non-coplanar triangles', ( assert ) => {
 
 			testEdges( vertList, [ 0, 1, 2, 0, 4, 2 ], 5, assert );
 
 		} );
 
-		QUnit.test( "three triangles, coplanar first", ( assert ) => {
+		QUnit.test( 'three triangles, coplanar first', ( assert ) => {
 
 			testEdges( vertList, [ 0, 2, 3, 0, 1, 2, 0, 4, 2 ], 7, assert );
 
 		} );
 
-		QUnit.test( "three triangles, coplanar last", ( assert ) => {
+		QUnit.test( 'three triangles, coplanar last', ( assert ) => {
 
 			testEdges( vertList, [ 0, 1, 2, 0, 4, 2, 0, 2, 3 ], 6, assert ); // Should be 7
 
 		} );
 
-		QUnit.test( "tetrahedron", ( assert ) => {
+		QUnit.test( 'tetrahedron', ( assert ) => {
 
 			testEdges( vertList, [ 0, 1, 2, 0, 1, 4, 0, 4, 2, 1, 2, 4 ], 6, assert );
 

test/unit/src/geometries/ExtrudeGeometry.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Geometries', () => {
 	QUnit.module( 'ExtrudeGeometry', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/IcosahedronGeometry.tests.js

@@ -25,16 +25,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/LatheGeometry.tests.js

@@ -25,16 +25,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/OctahedronGeometry.tests.js

@@ -25,16 +25,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/PlaneGeometry.tests.js

@@ -29,16 +29,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/PolyhedronGeometry.tests.js

@@ -26,16 +26,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/RingGeometry.tests.js

@@ -33,16 +33,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/ShapeGeometry.tests.js

@@ -24,23 +24,23 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
 		QUnit.todo( 'Standard geometry tests', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/SphereGeometry.tests.js

@@ -35,16 +35,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/TetrahedronGeometry.tests.js

@@ -25,16 +25,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/TorusGeometry.tests.js

@@ -31,16 +31,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/TorusKnotGeometry.tests.js

@@ -32,16 +32,16 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/TubeGeometry.tests.js

@@ -22,23 +22,23 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
 		QUnit.todo( 'Standard geometry tests', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/geometries/WireframeGeometry.tests.js

@@ -16,23 +16,23 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
 		QUnit.todo( 'Standard geometry tests', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/ArrowHelper.tests.js

@@ -7,35 +7,35 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'ArrowHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "setDirection", ( assert ) => {
+		QUnit.todo( 'setDirection', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setLength", ( assert ) => {
+		QUnit.todo( 'setLength', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setColor", ( assert ) => {
+		QUnit.todo( 'setColor', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/AxesHelper.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'AxesHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/Box3Helper.tests.js

@@ -7,23 +7,23 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'Box3Helper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "updateMatrixWorld", ( assert ) => {
+		QUnit.todo( 'updateMatrixWorld', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/BoxHelper.tests.js

@@ -29,29 +29,29 @@ export default QUnit.module( 'Helpers', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "setFromObject", ( assert ) => {
+		QUnit.todo( 'setFromObject', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/CameraHelper.tests.js

@@ -7,23 +7,23 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'CameraHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/DirectionalLightHelper.tests.js

@@ -7,29 +7,29 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'DirectionalLightHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "dispose", ( assert ) => {
+		QUnit.todo( 'dispose', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/GridHelper.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'GridHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/HemisphereLightHelper.tests.js

@@ -7,29 +7,29 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'HemisphereLightHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "dispose", ( assert ) => {
+		QUnit.todo( 'dispose', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/PlaneHelper.tests.js

@@ -7,23 +7,23 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'PlaneHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "updateMatrixWorld", ( assert ) => {
+		QUnit.todo( 'updateMatrixWorld', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/PointLightHelper.tests.js

@@ -7,29 +7,29 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'PointLightHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "dispose", ( assert ) => {
+		QUnit.todo( 'dispose', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/PolarGridHelper.tests.js

@@ -7,16 +7,16 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'PolarGridHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/SkeletonHelper.tests.js

@@ -7,23 +7,23 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'SkeletonHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "updateMatrixWorld", ( assert ) => {
+		QUnit.todo( 'updateMatrixWorld', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/helpers/SpotLightHelper.tests.js

@@ -7,29 +7,29 @@ export default QUnit.module( 'Helpers', () => {
 	QUnit.module( 'SpotLightHelper', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "dispose", ( assert ) => {
+		QUnit.todo( 'dispose', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "update", ( assert ) => {
+		QUnit.todo( 'update', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/lights/AmbientLight.tests.js

@@ -24,23 +24,23 @@ export default QUnit.module( 'Lights', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isAmbiantLight", ( assert ) => {
+		QUnit.todo( 'isAmbiantLight', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/lights/DirectionalLight.tests.js

@@ -24,29 +24,29 @@ export default QUnit.module( 'Lights', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isDirectionalLight", ( assert ) => {
+		QUnit.todo( 'isDirectionalLight', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "copy", ( assert ) => {
+		QUnit.todo( 'copy', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/lights/DirectionalLightShadow.tests.js

@@ -9,43 +9,43 @@ export default QUnit.module( 'Lights', () => {
 	QUnit.module( 'DirectionalLightShadow', () => {
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// OTHERS
-		QUnit.test( "clone/copy", ( assert ) => {
+		QUnit.test( 'clone/copy', ( assert ) => {
 
 			var a = new DirectionalLightShadow();
 			var b = new DirectionalLightShadow();
 			var c;
 
-			assert.notDeepEqual( a, b, "Newly instanced shadows are not equal" );
+			assert.notDeepEqual( a, b, 'Newly instanced shadows are not equal' );
 
 			c = a.clone();
-			assert.smartEqual( a, c, "Shadows are identical after clone()" );
+			assert.smartEqual( a, c, 'Shadows are identical after clone()' );
 
 			c.mapSize.set( 1024, 1024 );
-			assert.notDeepEqual( a, c, "Shadows are different again after change" );
+			assert.notDeepEqual( a, c, 'Shadows are different again after change' );
 
 			b.copy( a );
-			assert.smartEqual( a, b, "Shadows are identical after copy()" );
+			assert.smartEqual( a, b, 'Shadows are identical after copy()' );
 
 			b.mapSize.set( 512, 512 );
-			assert.notDeepEqual( a, b, "Shadows are different again after change" );
+			assert.notDeepEqual( a, b, 'Shadows are different again after change' );
 
 		} );
 
-		QUnit.test( "toJSON", ( assert ) => {
+		QUnit.test( 'toJSON', ( assert ) => {
 
 			var light = new DirectionalLight();
 			var shadow = new DirectionalLightShadow();
@@ -58,7 +58,7 @@ export default QUnit.module( 'Lights', () => {
 			var json = light.toJSON();
 			var newLight = new ObjectLoader().parse( json );
 
-			assert.smartEqual( newLight.shadow, light.shadow, "Reloaded shadow is identical to the original one" );
+			assert.smartEqual( newLight.shadow, light.shadow, 'Reloaded shadow is identical to the original one' );
 
 		} );
 

test/unit/src/lights/HemisphereLight.tests.js

@@ -26,29 +26,29 @@ export default QUnit.module( 'Lights', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isHemisphereLight", ( assert ) => {
+		QUnit.todo( 'isHemisphereLight', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "copy", ( assert ) => {
+		QUnit.todo( 'copy', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/lights/Light.tests.js

@@ -24,35 +24,35 @@ export default QUnit.module( 'Lights', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( "Extending", ( assert ) => {
+		QUnit.todo( 'Extending', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// INSTANCING
-		QUnit.todo( "Instancing", ( assert ) => {
+		QUnit.todo( 'Instancing', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
 		// PUBLIC STUFF
-		QUnit.todo( "isLight", ( assert ) => {
+		QUnit.todo( 'isLight', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "copy", ( assert ) => {
+		QUnit.todo( 'copy', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		QUnit.todo( "toJSON", ( assert ) => {
+		QUnit.todo( 'toJSON', ( assert ) => {
 
-			assert.ok( false, "everything's gonna be alright" );
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );