Tests: Unit Tests for Core (#25402)

* Add UniformsGroup unit tests.

UniformsGroup extends from EventDispatcher
UniformsGroup.isUniformsGroup should be true

* Add GLBufferAttribute unit tests.

GLBufferAttribute.isGLBufferAttribute should be true

* Update Object3D.tests.js

Object3D extends from EventDispatcher
Stub missing member tests.
Explicit block scope for variables used in tests.

* Update BufferAttribute.tests.js

BufferAttribute.isBufferAttribute should be true
Stub missing member tests.
Explicit block scope for variables used in tests.
Int8BufferAttribute extends from BufferAttribute
Uint8BufferAttribute extends from BufferAttribute
Uint8ClampedBufferAttribute extends from BufferAttribute
Int16BufferAttribute extends from BufferAttribute
Uint16BufferAttribute extends from BufferAttribute
Int32BufferAttribute extends from BufferAttribute
Uint32BufferAttribute extends from BufferAttribute
Float16BufferAttribute extends from BufferAttribute
Float32BufferAttribute extends from BufferAttribute
Float64BufferAttribute extends from BufferAttribute

* Update BufferGeometry.tests.js

BufferGeometry extends from EventDispatcher
BufferGeometry.type should be BufferGeometry
Stub missing member tests.
Explicit block scope for variables used in tests.

* Update Clock.tests.js

Stub missing member tests.
Explicit block scope for variables used in tests.

* Update EventDispatcher.tests.js

Explicit block scope for variables used in tests.

* Update InstancedBufferAttribute.tests.js

BufferAttribute extends from BufferAttribute
InstancedBufferAttribute.isInstancedBufferAttribute should be true
Explicit block scope for variables used in tests.
Stub missing member tests.

* Update InstancedBufferGeometry.tests.js

InstancedBufferGeometry extends from BufferGeometry
InstancedBufferGeometry.type should be InstancedBufferGeometry
InstancedBufferGeometry.isInstancedBufferGeometry should be true
Explicit block scope for variables used in tests.
Stub missing member tests.

* Update InstancedInterleavedBuffer.tests.js

InstancedInterleavedBuffer extends from InterleavedBuffer
InstancedInterleavedBuffer.isInstancedInterleavedBuffer should be true
Explicit block scope for variables used in tests.
Stub missing member tests.

* Update InterleavedBuffer.tests.js

InterleavedBuffer.isInterleavedBuffer should be true
Stub missing member tests.
Explicit block scope for variables used in tests.

* Update InterleavedBufferAttribute.tests.js

InterleavedBufferAttribute.isInterleavedBufferAttribute should be true
Explicit block scope for variables used in tests.
Stub missing member tests.

* Update Layers.tests.js

Explicit block scope for variables used in tests.
Stub missing member tests.

* Update Raycaster.tests.js

Explicit block scope for variables used in tests.
Stub missing member tests.

* Update Uniform.tests.js

Explicit block scope for variables used in tests.
Stub missing member test.

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

@@ -1,6 +1,20 @@
 /* global QUnit */
 
 import { BufferAttribute } from '../../../../src/core/BufferAttribute.js';
+
+import {
+	Int8BufferAttribute,
+	Uint8BufferAttribute,
+	Uint8ClampedBufferAttribute,
+	Int16BufferAttribute,
+	Uint16BufferAttribute,
+	Int32BufferAttribute,
+	Uint32BufferAttribute,
+	Float16BufferAttribute,
+	Float32BufferAttribute,
+	Float64BufferAttribute
+} from '../../../../src/core/BufferAttribute.js';
+
 import { DynamicDrawUsage } from '../../../../src/constants.js';
 
 export default QUnit.module( 'Core', () => {
@@ -23,22 +37,83 @@ export default QUnit.module( 'Core', () => {
 		} );
 
 		// PROPERTIES
-		QUnit.todo( 'needsUpdate', ( assert ) => {
+		QUnit.todo( 'name', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'array', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'itemSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'count', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalized', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'usage', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'updateRange', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'version', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'onUploadCallback', ( assert ) => {
 
+			// onUploadCallback() {}
+			// defined as member function but set property. refactor req
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isBufferAttribute', ( assert ) => {
+		QUnit.todo( 'needsUpdate', ( assert ) => {
 
+			// set needsUpdate( value )
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		// PUBLIC
+		QUnit.test( 'isBufferAttribute', ( assert ) => {
+
+			const object = new BufferAttribute();
+			assert.ok(
+				object.isBufferAttribute,
+				'BufferAttribute.isBufferAttribute should be true'
+			);
+
+		} );
+
 		QUnit.test( 'setUsage', ( assert ) => {
 
-			var attr = new BufferAttribute();
+			const attr = new BufferAttribute();
 			attr.setUsage( DynamicDrawUsage );
 
 			assert.strictEqual( attr.usage, DynamicDrawUsage, 'Usage was set' );
@@ -47,11 +122,11 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'copy', ( assert ) => {
 
-			var attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 );
+			const attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 );
 			attr.setUsage( DynamicDrawUsage );
 			attr.needsUpdate = true;
 
-			var attrCopy = new BufferAttribute().copy( attr );
+			const attrCopy = new BufferAttribute().copy( attr );
 
 			assert.ok( attr.count === attrCopy.count, 'count is equal' );
 			assert.ok( attr.itemSize === attrCopy.itemSize, 'itemSize is equal' );
@@ -63,15 +138,15 @@ export default QUnit.module( 'Core', () => {
 
 		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 );
+			const attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ), 3 );
+			const attr2 = new BufferAttribute( new Float32Array( 9 ), 3 );
 
 			attr2.copyAt( 1, attr, 2 );
 			attr2.copyAt( 0, attr, 1 );
 			attr2.copyAt( 2, attr, 0 );
 
-			var i = attr.array;
-			var i2 = attr2.array; // should be [4, 5, 6, 7, 8, 9, 1, 2, 3]
+			const i = attr.array;
+			const i2 = attr2.array; // should be [4, 5, 6, 7, 8, 9, 1, 2, 3]
 
 			assert.ok( i2[ 0 ] === i[ 3 ] && i2[ 1 ] === i[ 4 ] && i2[ 2 ] === i[ 5 ], 'chunck copied to correct place' );
 			assert.ok( i2[ 3 ] === i[ 6 ] && i2[ 4 ] === i[ 7 ] && i2[ 5 ] === i[ 8 ], 'chunck copied to correct place' );
@@ -81,8 +156,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'copyArray', ( assert ) => {
 
-			var f32a = new Float32Array( [ 5, 6, 7, 8 ] );
-			var a = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4 ] ), 2, false );
+			const f32a = new Float32Array( [ 5, 6, 7, 8 ] );
+			const a = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4 ] ), 2, false );
 
 			a.copyArray( f32a );
 
@@ -90,11 +165,39 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'applyMatrix3', ( assert ) => {
+
+			// applyMatrix3( m )
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'applyMatrix4', ( assert ) => {
+
+			// applyMatrix4( m )
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'applyNormalMatrix', ( assert ) => {
+
+			// applyNormalMatrix( m )
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transformDirection', ( assert ) => {
+
+			// transformDirection( m )
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.test( 'set', ( assert ) => {
 
-			var f32a = new Float32Array( [ 1, 2, 3, 4 ] );
-			var a = new BufferAttribute( f32a, 2, false );
-			var expected = new Float32Array( [ 9, 2, 8, 4 ] );
+			const f32a = new Float32Array( [ 1, 2, 3, 4 ] );
+			const a = new BufferAttribute( f32a, 2, false );
+			const expected = new Float32Array( [ 9, 2, 8, 4 ] );
 
 			a.set( [ 9 ] );
 			a.set( [ 8 ], 2 );
@@ -105,9 +208,9 @@ export default QUnit.module( 'Core', () => {
 
 		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 );
-			var expected = new Float32Array( [ 1, 2, - 3, - 4, - 5, - 6, 7, 8 ] );
+			const f32a = new Float32Array( [ 1, 2, 3, 4, 5, 6, 7, 8 ] );
+			const a = new BufferAttribute( f32a, 4, false );
+			const expected = new Float32Array( [ 1, 2, - 3, - 4, - 5, - 6, 7, 8 ] );
 
 			a.setX( 1, a.getX( 1 ) * - 1 );
 			a.setY( 1, a.getY( 1 ) * - 1 );
@@ -120,9 +223,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setXY', ( assert ) => {
 
-			var f32a = new Float32Array( [ 1, 2, 3, 4 ] );
-			var a = new BufferAttribute( f32a, 2, false );
-			var expected = new Float32Array( [ - 1, - 2, 3, 4 ] );
+			const f32a = new Float32Array( [ 1, 2, 3, 4 ] );
+			const a = new BufferAttribute( f32a, 2, false );
+			const expected = new Float32Array( [ - 1, - 2, 3, 4 ] );
 
 			a.setXY( 0, - 1, - 2 );
 
@@ -132,9 +235,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setXYZ', ( assert ) => {
 
-			var f32a = new Float32Array( [ 1, 2, 3, 4, 5, 6 ] );
-			var a = new BufferAttribute( f32a, 3, false );
-			var expected = new Float32Array( [ 1, 2, 3, - 4, - 5, - 6 ] );
+			const f32a = new Float32Array( [ 1, 2, 3, 4, 5, 6 ] );
+			const a = new BufferAttribute( f32a, 3, false );
+			const expected = new Float32Array( [ 1, 2, 3, - 4, - 5, - 6 ] );
 
 			a.setXYZ( 1, - 4, - 5, - 6 );
 
@@ -144,9 +247,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setXYZW', ( assert ) => {
 
-			var f32a = new Float32Array( [ 1, 2, 3, 4 ] );
-			var a = new BufferAttribute( f32a, 4, false );
-			var expected = new Float32Array( [ - 1, - 2, - 3, - 4 ] );
+			const f32a = new Float32Array( [ 1, 2, 3, 4 ] );
+			const a = new BufferAttribute( f32a, 4, false );
+			const expected = new Float32Array( [ - 1, - 2, - 3, - 4 ] );
 
 			a.setXYZW( 0, - 1, - 2, - 3, - 4 );
 
@@ -156,8 +259,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'onUpload', ( assert ) => {
 
-			var a = new BufferAttribute();
-			var func = function () { };
+			const a = new BufferAttribute();
+			const func = function () { };
 
 			a.onUpload( func );
 
@@ -167,11 +270,11 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'clone', ( assert ) => {
 
-			var attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 0.12, - 12 ] ), 2 );
-			var attrCopy = attr.clone();
+			const attr = new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 0.12, - 12 ] ), 2 );
+			const attrCopy = attr.clone();
 
 			assert.ok( attr.array.length === attrCopy.array.length, 'attribute was cloned' );
-			for ( var i = 0; i < attr.array.length; i ++ ) {
+			for ( let i = 0; i < attr.array.length; i ++ ) {
 
 				assert.ok( attr.array[ i ] === attrCopy.array[ i ], 'array item is equal' );
 
@@ -221,9 +324,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Int8BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Int8BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Int8BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -239,9 +346,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint8BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Uint8BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Uint8BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -257,9 +368,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint8ClampedBufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Uint8ClampedBufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Uint8ClampedBufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -275,9 +390,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Int16BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Int16BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Int16BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -293,9 +412,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint16BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Uint16BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Uint16BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -311,9 +434,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Int32BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Int32BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Int32BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -329,12 +456,38 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Uint32BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
+
+			const object = new Uint32BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Uint32BufferAttribute extends from BufferAttribute'
+			);
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+	} );
+
+	QUnit.module( 'Float16BufferAttribute', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			const object = new Float16BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Float16BufferAttribute extends from BufferAttribute'
+			);
+
+		} );
+
 		// INSTANCING
 		QUnit.todo( 'Instancing', ( assert ) => {
 
@@ -347,9 +500,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Float32BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Float32BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Float32BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
@@ -365,9 +522,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'Float64BufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new Float64BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'Float64BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 

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

@@ -1,6 +1,7 @@
 /* global QUnit */
 
 import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+
 import {
 	BufferAttribute,
 	Uint16BufferAttribute,
@@ -11,8 +12,9 @@ import { Matrix4 } from '../../../../src/math/Matrix4.js';
 import { Quaternion } from '../../../../src/math/Quaternion.js';
 import { Sphere } from '../../../../src/math/Sphere.js';
 import { x, y, z } from '../../utils/math-constants.js';
+import { EventDispatcher } from '../../../../src/core/EventDispatcher.js';
 
-var DegToRad = Math.PI / 180;
+const DegToRad = Math.PI / 180;
 
 function bufferAttributeEquals( a, b, tolerance ) {
 
@@ -24,9 +26,9 @@ function bufferAttributeEquals( a, b, tolerance ) {
 
 	}
 
-	for ( var i = 0, il = a.count * a.itemSize; i < il; i ++ ) {
+	for ( let i = 0, il = a.count * a.itemSize; i < il; i ++ ) {
 
-		var delta = a[ i ] - b[ i ];
+		const delta = a[ i ] - b[ i ];
 		if ( delta > tolerance ) {
 
 			return false;
@@ -41,7 +43,7 @@ function bufferAttributeEquals( a, b, tolerance ) {
 
 function getBBForVertices( vertices ) {
 
-	var geometry = new BufferGeometry();
+	const geometry = new BufferGeometry();
 
 	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( vertices ), 3 ) );
 	geometry.computeBoundingBox();
@@ -52,7 +54,7 @@ function getBBForVertices( vertices ) {
 
 function getBSForVertices( vertices ) {
 
-	var geometry = new BufferGeometry();
+	const geometry = new BufferGeometry();
 
 	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( vertices ), 3 ) );
 	geometry.computeBoundingSphere();
@@ -63,7 +65,7 @@ function getBSForVertices( vertices ) {
 
 function getNormalsForVertices( vertices, assert ) {
 
-	var geometry = new BufferGeometry();
+	const geometry = new BufferGeometry();
 
 	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( vertices ), 3 ) );
 
@@ -80,9 +82,13 @@ export default QUnit.module( 'Core', () => {
 	QUnit.module( 'BufferGeometry', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new BufferGeometry();
+			assert.strictEqual(
+				object instanceof EventDispatcher, true,
+				'BufferGeometry extends from EventDispatcher'
+			);
 
 		} );
 
@@ -93,19 +99,106 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isBufferGeometry', ( assert ) => {
+		// PROPERTIES
+		QUnit.todo( 'id', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'uuid', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'name', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new BufferGeometry();
+			assert.ok(
+				object.type === 'BufferGeometry',
+				'BufferGeometry.type should be BufferGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'index', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'attributes', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'morphAttributes', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'morphTargetsRelative', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'groups', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'boundingBox', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'boundingSphere', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'drawRange', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'userData', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isBufferGeometry', ( assert ) => {
+
+			const object = new BufferGeometry();
+			assert.ok(
+				object.isBufferGeometry,
+				'BufferGeometry.isBufferGeometry should be true'
+			);
+
+		} );
+
 		QUnit.test( 'setIndex/getIndex', ( assert ) => {
 
-			var a = new BufferGeometry();
-			var uint16 = [ 1, 2, 3 ];
-			var uint32 = [ 65535, 65536, 65537 ];
-			var str = 'foo';
+			const a = new BufferGeometry();
+			const uint16 = [ 1, 2, 3 ];
+			const uint32 = [ 65535, 65536, 65537 ];
+			const str = 'foo';
 
 			a.setIndex( uint16 );
 			assert.ok( a.getIndex() instanceof Uint16BufferAttribute, 'Index has the right type' );
@@ -128,8 +221,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'set / delete Attribute', ( assert ) => {
 
-			var geometry = new BufferGeometry();
-			var attributeName = 'position';
+			const geometry = new BufferGeometry();
+			const attributeName = 'position';
 
 			assert.ok( geometry.attributes[ attributeName ] === undefined, 'no attribute defined' );
 
@@ -145,8 +238,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'addGroup', ( assert ) => {
 
-			var a = new BufferGeometry();
-			var expected = [
+			const a = new BufferGeometry();
+			const expected = [
 				{
 					start: 0,
 					count: 1,
@@ -176,7 +269,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setDrawRange', ( assert ) => {
 
-			var a = new BufferGeometry();
+			const a = new BufferGeometry();
 
 			a.setDrawRange( 1.0, 7 );
 
@@ -189,10 +282,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'applyMatrix4', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const geometry = new BufferGeometry();
 			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 6 ), 3 ) );
 
-			var matrix = new Matrix4().set(
+			const matrix = new Matrix4().set(
 				1, 0, 0, 1.5,
 				0, 1, 0, - 2,
 				0, 0, 1, 3,
@@ -200,8 +293,8 @@ export default QUnit.module( 'Core', () => {
 			);
 			geometry.applyMatrix4( matrix );
 
-			var position = geometry.attributes.position.array;
-			var m = matrix.elements;
+			const position = geometry.attributes.position.array;
+			const 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' );
@@ -210,13 +303,13 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'applyQuaternion', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const geometry = new BufferGeometry();
 			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 );
+			const q = new Quaternion( 0.5, 0.5, 0.5, 0.5 );
 			geometry.applyQuaternion( q );
 
-			var pos = geometry.attributes.position.array;
+			const pos = geometry.attributes.position.array;
 
 			// geometry was rotated around the (1, 1, 1) axis.
 			assert.ok( pos[ 0 ] === 3 && pos[ 1 ] === 1 && pos[ 2 ] === 2 &&
@@ -226,10 +319,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'rotateX/Y/Z', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const geometry = new BufferGeometry();
 			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
 
-			var pos = geometry.attributes.position.array;
+			const pos = geometry.attributes.position.array;
 
 			geometry.rotateX( 180 * DegToRad );
 
@@ -253,10 +346,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'translate', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const geometry = new BufferGeometry();
 			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ 1, 2, 3, 4, 5, 6 ] ), 3 ) );
 
-			var pos = geometry.attributes.position.array;
+			const pos = geometry.attributes.position.array;
 
 			geometry.translate( 10, 20, 30 );
 
@@ -267,10 +360,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'scale', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const geometry = new BufferGeometry();
 			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [ - 1, - 1, - 1, 2, 2, 2 ] ), 3 ) );
 
-			var pos = geometry.attributes.position.array;
+			const pos = geometry.attributes.position.array;
 
 			geometry.scale( 1, 2, 3 );
 
@@ -281,8 +374,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'lookAt', ( assert ) => {
 
-			var a = new BufferGeometry();
-			var vertices = new Float32Array( [
+			const a = new BufferGeometry();
+			const vertices = new Float32Array( [
 				- 1.0, - 1.0, 1.0,
 				1.0, - 1.0, 1.0,
 				1.0, 1.0, 1.0,
@@ -293,8 +386,8 @@ export default QUnit.module( 'Core', () => {
 			] );
 			a.setAttribute( 'position', new BufferAttribute( vertices, 3 ) );
 
-			var sqrt = Math.sqrt( 2 );
-			var expected = new Float32Array( [
+			const sqrt = Math.sqrt( 2 );
+			const expected = new Float32Array( [
 				1, 0, - sqrt,
 				- 1, 0, - sqrt,
 				- 1, sqrt, 0,
@@ -312,7 +405,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'center', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const geometry = new BufferGeometry();
 			geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [
 				- 1, - 1, - 1,
 				1, 1, 1,
@@ -321,7 +414,7 @@ export default QUnit.module( 'Core', () => {
 
 			geometry.center();
 
-			var pos = geometry.attributes.position.array;
+			const pos = geometry.attributes.position.array;
 
 			// the boundingBox should go from (-1, -1, -1) to (4, 4, 4) so it has a size of (5, 5, 5)
 			// after centering it the vertices should be placed between (-2.5, -2.5, -2.5) and (2.5, 2.5, 2.5)
@@ -331,14 +424,20 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'setFromPoints', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.test( 'computeBoundingBox', ( assert ) => {
 
-			var bb = getBBForVertices( [ - 1, - 2, - 3, 13, - 2, - 3.5, - 1, - 20, 0, - 4, 5, 6 ] );
+			let 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' );
 
-			var bb = getBBForVertices( [ - 1, - 1, - 1 ] );
+			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' );
@@ -347,23 +446,29 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'computeBoundingSphere', ( assert ) => {
 
-			var bs = getBSForVertices( [ - 10, 0, 0, 10, 0, 0 ] );
+			let bs = getBSForVertices( [ - 10, 0, 0, 10, 0, 0 ] );
 
 			assert.ok( bs.radius === 10, '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();
+			bs = getBSForVertices( [ - 5, 11, - 3, 5, - 11, 3 ] );
+			const 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 )' );
 
 		} );
 
+		QUnit.todo( 'computeTangents', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		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 );
+			let 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' );
@@ -375,7 +480,7 @@ export default QUnit.module( 'Core', () => {
 				'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 );
+			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' );
@@ -386,7 +491,7 @@ export default QUnit.module( 'Core', () => {
 			assert.ok( normals[ 6 ] === 0 && normals[ 7 ] === 0 && normals[ 8 ] === - 1,
 				'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 );
+			normals = getNormalsForVertices( [ 0, 0, 1, 0, 0, - 1, 1, 1, 0 ], assert );
 
 			// the triangle is rotated by 45 degrees to the right so the normals of the three vertices
 			// should point to (1, -1, 0).normalized(). The simplest solution is to check against a normalized
@@ -394,37 +499,38 @@ export default QUnit.module( 'Core', () => {
 			// valid technique is to create a vector which stands in 90 degrees to the normals and calculate the
 			// dot product which is the cos of the angle between them. This should be < floating calculation error
 			// 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 ] ) );
+			const direction = new Vector3( 1, 1, 0 ).normalize(); // a vector which should have 90 degrees difference to normals
+			const difference = direction.dot( new Vector3( normals[ 0 ], normals[ 1 ], normals[ 2 ] ) );
 			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 ++ ) {
+			normals = getNormalsForVertices( [ 1, 0, 0, - 1, 0, 0 ], assert );
+			for ( let i = 0; i < normals.length; i ++ ) {
 
 				assert.ok( ! normals[ i ], 'normals can\'t be calculated which is good' );
 
 			}
 
 		} );
+
 		QUnit.test( 'computeVertexNormals (indexed)', ( assert ) => {
 
-			var sqrt = 0.5 * Math.sqrt( 2 );
-			var normal = new BufferAttribute( new Float32Array( [
+			const sqrt = 0.5 * Math.sqrt( 2 );
+			const normal = new BufferAttribute( new Float32Array( [
 				- 1, 0, 0, - 1, 0, 0, - 1, 0, 0,
 				sqrt, sqrt, 0, sqrt, sqrt, 0, sqrt, sqrt, 0,
 				- 1, 0, 0
 			] ), 3 );
-			var position = new BufferAttribute( new Float32Array( [
+			const position = new BufferAttribute( new Float32Array( [
 				0.5, 0.5, 0.5, 0.5, 0.5, - 0.5, 0.5, - 0.5, 0.5,
 				0.5, - 0.5, - 0.5, - 0.5, 0.5, - 0.5, - 0.5, 0.5, 0.5,
 				- 0.5, - 0.5, - 0.5
 			] ), 3 );
-			var index = new BufferAttribute( new Uint16Array( [
+			const index = new BufferAttribute( new Uint16Array( [
 				0, 2, 1, 2, 3, 1, 4, 6, 5, 6, 7, 5
 			] ), 1 );
 
-			var a = new BufferGeometry();
+			let a = new BufferGeometry();
 			a.setAttribute( 'position', position );
 			a.computeVertexNormals();
 			assert.ok(
@@ -440,7 +546,7 @@ export default QUnit.module( 'Core', () => {
 			);
 
 			// indexed geometry
-			var a = new BufferGeometry();
+			a = new BufferGeometry();
 			a.setAttribute( 'position', position );
 			a.setIndex( index );
 			a.computeVertexNormals();
@@ -456,12 +562,12 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'toNonIndexed', ( assert ) => {
 
-			var geometry = new BufferGeometry();
-			var vertices = new Float32Array( [
+			const geometry = new BufferGeometry();
+			const vertices = new Float32Array( [
 				0.5, 0.5, 0.5, 0.5, 0.5, - 0.5, 0.5, - 0.5, 0.5, 0.5, - 0.5, - 0.5
 			] );
-			var index = new BufferAttribute( new Uint16Array( [ 0, 2, 1, 2, 3, 1 ] ) );
-			var expected = new Float32Array( [
+			const index = new BufferAttribute( new Uint16Array( [ 0, 2, 1, 2, 3, 1 ] ) );
+			const expected = new Float32Array( [
 				0.5, 0.5, 0.5, 0.5, - 0.5, 0.5, 0.5, 0.5, - 0.5,
 				0.5, - 0.5, 0.5, 0.5, - 0.5, - 0.5, 0.5, 0.5, - 0.5
 			] );
@@ -469,7 +575,7 @@ export default QUnit.module( 'Core', () => {
 			geometry.setAttribute( 'position', new BufferAttribute( vertices, 3 ) );
 			geometry.setIndex( index );
 
-			var nonIndexed = geometry.toNonIndexed();
+			const nonIndexed = geometry.toNonIndexed();
 
 			assert.deepEqual( nonIndexed.getAttribute( 'position' ).array, expected, 'Expected vertices' );
 
@@ -477,18 +583,18 @@ export default QUnit.module( 'Core', () => {
 
 		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 );
+			const index = new BufferAttribute( new Uint16Array( [ 0, 1, 2, 3 ] ), 1 );
+			const attribute1 = new BufferAttribute( new Uint16Array( [ 1, 3, 5, 7 ] ), 1 );
 			attribute1.name = 'attribute1';
-			var a = new BufferGeometry();
+			const a = new BufferGeometry();
 			a.name = 'JSONQUnit.test';
 			// a.parameters = { "placeholder": 0 };
 			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 = {
+			let j = a.toJSON();
+			const gold = {
 				'metadata': {
 					'version': 4.5,
 					'type': 'BufferGeometry',
@@ -548,14 +654,14 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'clone', ( assert ) => {
 
-			var a = new BufferGeometry();
+			const 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.addGroup( 0, 1, 2 );
 			a.computeBoundingBox();
 			a.computeBoundingSphere();
 			a.setDrawRange( 0, 1 );
-			var b = a.clone();
+			const b = a.clone();
 
 			assert.notEqual( a, b, 'A new object was created' );
 			assert.notEqual( a.id, b.id, 'New object has a different GUID' );
@@ -585,20 +691,20 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'copy', ( assert ) => {
 
-			var geometry = new BufferGeometry();
+			const 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 ) );
 
-			var copy = new BufferGeometry().copy( geometry );
+			const copy = new BufferGeometry().copy( geometry );
 
 			assert.ok( copy !== geometry && geometry.id !== copy.id, 'new object was created' );
 
 			Object.keys( geometry.attributes ).forEach( function ( key ) {
 
-				var attribute = geometry.attributes[ key ];
+				const attribute = geometry.attributes[ key ];
 				assert.ok( attribute !== undefined, 'all attributes where copied' );
 
-				for ( var i = 0; i < attribute.array.length; i ++ ) {
+				for ( let i = 0; i < attribute.array.length; i ++ ) {
 
 					assert.ok( attribute.array[ i ] === copy.attributes[ key ].array[ i ], 'values of the attribute are equal' );
 

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

@@ -36,7 +36,38 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'autoStart', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'startTime', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'oldTime', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'elapsedTime', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'running', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
 		QUnit.todo( 'start', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
@@ -73,7 +104,7 @@ export default QUnit.module( 'Core', () => {
 
 			mockPerformance();
 
-			var clock = new Clock( false );
+			const clock = new Clock( false );
 
 			clock.start();
 

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

@@ -13,12 +13,12 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PUBLIC
 		QUnit.test( 'addEventListener', ( assert ) => {
 
-			var eventDispatcher = new EventDispatcher();
+			const eventDispatcher = new EventDispatcher();
 
-			var listener = {};
+			const listener = {};
 			eventDispatcher.addEventListener( 'anyType', listener );
 
 			assert.ok( eventDispatcher._listeners.anyType.length === 1, 'listener with unknown type was added' );
@@ -33,9 +33,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'hasEventListener', ( assert ) => {
 
-			var eventDispatcher = new EventDispatcher();
+			const eventDispatcher = new EventDispatcher();
 
-			var listener = {};
+			const listener = {};
 			eventDispatcher.addEventListener( 'anyType', listener );
 
 			assert.ok( eventDispatcher.hasEventListener( 'anyType', listener ), 'listener was found' );
@@ -45,9 +45,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'removeEventListener', ( assert ) => {
 
-			var eventDispatcher = new EventDispatcher();
+			const eventDispatcher = new EventDispatcher();
 
-			var listener = {};
+			const listener = {};
 
 			assert.ok( eventDispatcher._listeners === undefined, 'there are no listeners by default' );
 
@@ -68,10 +68,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'dispatchEvent', ( assert ) => {
 
-			var eventDispatcher = new EventDispatcher();
+			const eventDispatcher = new EventDispatcher();
 
-			var callCount = 0;
-			var listener = function () {
+			let callCount = 0;
+			const listener = function () {
 
 				callCount ++;
 

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

@@ -0,0 +1,103 @@
+/* global QUnit */
+
+import { GLBufferAttribute } from '../../../../src/core/GLBufferAttribute.js';
+
+export default QUnit.module( 'Core', () => {
+
+	QUnit.module( 'GLBufferAttribute', () => {
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PROPERTIES
+		QUnit.todo( 'name', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'buffer', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'type', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'itemSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'elementSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'count', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'version', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'needsUpdate', ( assert ) => {
+
+			// set needsUpdate( value )
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isGLBufferAttribute', ( assert ) => {
+
+			const object = new GLBufferAttribute();
+			assert.ok(
+				object.isGLBufferAttribute,
+				'GLBufferAttribute.isGLBufferAttribute should be true'
+			);
+
+		} );
+
+		QUnit.todo( 'setBuffer', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setItemSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setCount', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

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

@@ -2,41 +2,64 @@
 
 import { InstancedBufferAttribute } from '../../../../src/core/InstancedBufferAttribute.js';
 
+import { BufferAttribute } from '../../../../src/core/BufferAttribute.js';
+
 export default QUnit.module( 'Core', () => {
 
 	QUnit.module( 'InstancedBufferAttribute', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new BufferAttribute();
+			assert.strictEqual(
+				object instanceof BufferAttribute, true,
+				'BufferAttribute extends from BufferAttribute'
+			);
 
 		} );
 
 		// INSTANCING
 		QUnit.test( 'Instancing', ( assert ) => {
 
-			var instance = new InstancedBufferAttribute( new Float32Array( 10 ), 2 );
+			let instance = new InstancedBufferAttribute( new Float32Array( 10 ), 2 );
 			assert.ok( instance.meshPerAttribute === 1, 'ok' );
 
-			var instance = new InstancedBufferAttribute( new Float32Array( 10 ), 2, false, 123 );
+			instance = new InstancedBufferAttribute( new Float32Array( 10 ), 2, false, 123 );
 			assert.ok( instance.meshPerAttribute === 123, 'ok' );
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'meshPerAttribute', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isInstancedBufferAttribute', ( assert ) => {
+
+			const object = new InstancedBufferAttribute();
+			assert.ok(
+				object.isInstancedBufferAttribute,
+				'InstancedBufferAttribute.isInstancedBufferAttribute should be true'
+			);
+
+		} );
+
 		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 );
+			const array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
+			const instance = new InstancedBufferAttribute( array, 2, true, 123 );
+			const 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' );
 
-			for ( var i = 0; i < array.length; i ++ ) {
+			for ( let i = 0; i < array.length; i ++ ) {
 
 				assert.ok( copiedInstance.array[ i ] === array[ i ], 'array was copied' );
 
@@ -44,6 +67,12 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 	} );
 
 } );

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

@@ -1,6 +1,8 @@
 /* global QUnit */
 
 import { InstancedBufferGeometry } from '../../../../src/core/InstancedBufferGeometry.js';
+
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
 import { BufferAttribute } from '../../../../src/core/BufferAttribute.js';
 
 export default QUnit.module( 'Core', () => {
@@ -22,9 +24,13 @@ export default QUnit.module( 'Core', () => {
 		}
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new InstancedBufferGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'InstancedBufferGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -35,16 +41,43 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new InstancedBufferGeometry();
+			assert.ok(
+				object.type === 'InstancedBufferGeometry',
+				'InstancedBufferGeometry.type should be InstancedBufferGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'instanceCount', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isInstancedBufferGeometry', ( assert ) => {
+
+			const object = new InstancedBufferGeometry();
+			assert.ok(
+				object.isInstancedBufferGeometry,
+				'InstancedBufferGeometry.isInstancedBufferGeometry should be true'
+			);
+
+		} );
+
 		QUnit.test( 'copy', ( assert ) => {
 
-			var instanceMock1 = {};
-			var instanceMock2 = {};
-			var indexMock = createClonableMock();
-			var defaultAttribute1 = new BufferAttribute( new Float32Array( [ 1 ] ) );
-			var defaultAttribute2 = new BufferAttribute( new Float32Array( [ 2 ] ) );
+			const instanceMock1 = {};
+			const instanceMock2 = {};
+			const indexMock = createClonableMock();
+			const defaultAttribute1 = new BufferAttribute( new Float32Array( [ 1 ] ) );
+			const defaultAttribute2 = new BufferAttribute( new Float32Array( [ 2 ] ) );
 
-			var instance = new InstancedBufferGeometry();
+			const instance = new InstancedBufferGeometry();
 
 			instance.addGroup( 0, 10, instanceMock1 );
 			instance.addGroup( 10, 5, instanceMock2 );
@@ -52,7 +85,7 @@ export default QUnit.module( 'Core', () => {
 			instance.setAttribute( 'defaultAttribute1', defaultAttribute1 );
 			instance.setAttribute( 'defaultAttribute2', defaultAttribute2 );
 
-			var copiedInstance = new InstancedBufferGeometry().copy( instance );
+			const copiedInstance = new InstancedBufferGeometry().copy( instance );
 
 			assert.ok( copiedInstance instanceof InstancedBufferGeometry, 'the clone has the correct type' );
 
@@ -73,7 +106,7 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.todo( 'clone', ( assert ) => {
+		QUnit.todo( 'toJSON', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 

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

@@ -2,44 +2,73 @@
 
 import { InstancedInterleavedBuffer } from '../../../../src/core/InstancedInterleavedBuffer.js';
 
+import { InterleavedBuffer } from '../../../../src/core/InterleavedBuffer.js';
+
 export default QUnit.module( 'Core', () => {
 
 	QUnit.module( 'InstancedInterleavedBuffer', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new InstancedInterleavedBuffer();
+			assert.strictEqual(
+				object instanceof InterleavedBuffer, true,
+				'InstancedInterleavedBuffer extends from InterleavedBuffer'
+			);
 
 		} );
 
 		// INSTANCING
 		QUnit.test( 'Instancing', ( assert ) => {
 
-			var array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
-			var instance = new InstancedInterleavedBuffer( array, 3 );
+			const array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
+			const instance = new InstancedInterleavedBuffer( array, 3 );
 
 			assert.ok( instance.meshPerAttribute === 1, 'ok' );
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isInstancedInterleavedBuffer', ( assert ) => {
+		// PROPERTIES
+		QUnit.todo( 'meshPerAttribute', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		// PUBLIC
+		QUnit.test( 'isInstancedInterleavedBuffer', ( assert ) => {
+
+			const object = new InstancedInterleavedBuffer();
+			assert.ok(
+				object.isInstancedInterleavedBuffer,
+				'InstancedInterleavedBuffer.isInstancedInterleavedBuffer should be true'
+			);
+
+		} );
+
 		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 );
+			const array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
+			const instance = new InstancedInterleavedBuffer( array, 3 );
+			const copiedInstance = instance.copy( instance );
 
 			assert.ok( copiedInstance.meshPerAttribute === 1, 'additional attribute was copied' );
 
 		} );
 
+		QUnit.todo( 'clone', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 	} );
 
 } );

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

@@ -1,6 +1,7 @@
 /* global QUnit */
 
 import { InterleavedBuffer } from '../../../../src/core/InterleavedBuffer.js';
+
 import { DynamicDrawUsage } from '../../../../src/constants.js';
 
 export default QUnit.module( 'Core', () => {
@@ -11,7 +12,7 @@ export default QUnit.module( 'Core', () => {
 
 			assert.ok( copiedInstance instanceof InterleavedBuffer, 'the clone has the correct type' );
 
-			for ( var i = 0; i < instance.array.length; i ++ ) {
+			for ( let i = 0; i < instance.array.length; i ++ ) {
 
 				assert.ok( copiedInstance.array[ i ] === instance.array[ i ], 'array was copied' );
 
@@ -30,26 +31,78 @@ export default QUnit.module( 'Core', () => {
 		} );
 
 		// PROPERTIES
-		QUnit.test( 'needsUpdate', ( assert ) => {
+		QUnit.todo( 'array', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stride', ( assert ) => {
 
-			var a = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 4 ] ), 2 );
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'count', ( assert ) => {
 
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'usage', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'updateRange', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'version', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'uuid', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'onUploadCallback', ( assert ) => {
+
+			// onUploadCallback() {} declared but used as property, refactor req
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.test( 'needsUpdate', ( assert ) => {
+
+			const a = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 4 ] ), 2 );
 			a.needsUpdate = true;
 
 			assert.strictEqual( a.version, 1, 'Check version increased' );
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isInterleavedBuffer', ( assert ) => {
+		// PUBLIC
+		QUnit.test( 'isInterleavedBuffer', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new InterleavedBuffer();
+			assert.ok(
+				object.isInterleavedBuffer,
+				'InterleavedBuffer.isInterleavedBuffer should be true'
+			);
 
 		} );
 
 		QUnit.test( 'setUsage', ( assert ) => {
 
-			var instance = new InterleavedBuffer();
+			const instance = new InterleavedBuffer();
 			instance.setUsage( DynamicDrawUsage );
 
 			assert.strictEqual( instance.usage, DynamicDrawUsage, 'Usage was set' );
@@ -58,8 +111,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'copy', ( assert ) => {
 
-			var array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
-			var instance = new InterleavedBuffer( array, 3 );
+			const array = new Float32Array( [ 1, 2, 3, 7, 8, 9 ] );
+			const instance = new InterleavedBuffer( array, 3 );
 			instance.setUsage( DynamicDrawUsage );
 
 			checkInstanceAgainstCopy( instance, instance.copy( instance ), assert );
@@ -68,9 +121,9 @@ export default QUnit.module( 'Core', () => {
 
 		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 );
-			var expected = new Float32Array( [ 4, 5, 6, 7, 8, 9, 1, 2, 3 ] );
+			const a = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ), 3 );
+			const b = new InterleavedBuffer( new Float32Array( 9 ), 3 );
+			const expected = new Float32Array( [ 4, 5, 6, 7, 8, 9, 1, 2, 3 ] );
 
 			b.copyAt( 1, a, 2 );
 			b.copyAt( 0, a, 1 );
@@ -82,17 +135,23 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'set', ( assert ) => {
 
-			var instance = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
+			const 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' );
 
 		} );
 
+		QUnit.todo( 'clone', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.test( 'onUpload', ( assert ) => {
 
-			var a = new InterleavedBuffer();
-			var func = function () { };
+			const a = new InterleavedBuffer();
+			const func = function () { };
 
 			a.onUpload( func );
 
@@ -100,10 +159,16 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'count', ( assert ) => {
 
-			var instance = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
+			const instance = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
 
 			assert.equal( instance.count, 2, 'count is calculated via array length / stride' );
 

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

@@ -1,8 +1,9 @@
 /* global QUnit */
 
-import { InterleavedBuffer } from '../../../../src/core/InterleavedBuffer.js';
 import { InterleavedBufferAttribute } from '../../../../src/core/InterleavedBufferAttribute.js';
 
+import { InterleavedBuffer } from '../../../../src/core/InterleavedBuffer.js';
+
 export default QUnit.module( 'Core', () => {
 
 	QUnit.module( 'InterleavedBufferAttribute', () => {
@@ -15,10 +16,40 @@ export default QUnit.module( 'Core', () => {
 		} );
 
 		// PROPERTIES
+		QUnit.todo( 'name', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'data', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'itemSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'offset', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalized', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.test( 'count', ( assert ) => {
 
-			var buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
-			var instance = new InterleavedBufferAttribute( buffer, 2, 0 );
+			const buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
+			const instance = new InterleavedBufferAttribute( buffer, 2, 0 );
 
 			assert.ok( instance.count === 2, 'count is calculated via array length / stride' );
 
@@ -30,13 +61,48 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		QUnit.todo( 'needsUpdate', ( assert ) => {
+
+			// set needsUpdate( value )
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isInterleavedBufferAttribute', ( assert ) => {
+
+			const object = new InterleavedBufferAttribute();
+			assert.ok(
+				object.isInterleavedBufferAttribute,
+				'InterleavedBufferAttribute.isInterleavedBufferAttribute should be true'
+			);
+
+		} );
+
+		QUnit.todo( 'applyMatrix4', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'applyNormalMatrix', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transformDirection', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// 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 ) => {
 
-			var buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
-			var instance = new InterleavedBufferAttribute( buffer, 2, 0 );
+			let buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
+			let instance = new InterleavedBufferAttribute( buffer, 2, 0 );
 
 			instance.setX( 0, 123 );
 			instance.setX( 1, 321 );
@@ -44,8 +110,8 @@ export default QUnit.module( 'Core', () => {
 			assert.ok( instance.data.array[ 0 ] === 123 &&
 				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 );
+			buffer = new InterleavedBuffer( new Float32Array( [ 1, 2, 3, 7, 8, 9 ] ), 3 );
+			instance = new InterleavedBufferAttribute( buffer, 2, 1 );
 
 			instance.setX( 0, 123 );
 			instance.setX( 1, 321 );
@@ -116,6 +182,18 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'clone', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 	} );
 
 } );

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

@@ -13,12 +13,19 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'mask', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
 		QUnit.test( 'set', ( assert ) => {
 
-			var a = new Layers();
+			const a = new Layers();
 
-			for ( var i = 0; i < 31; i ++ ) {
+			for ( let i = 0; i < 31; i ++ ) {
 
 				a.set( i );
 				assert.strictEqual( a.mask, Math.pow( 2, i ), 'Mask has the expected value for channel: ' + i );
@@ -29,7 +36,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'enable', ( assert ) => {
 
-			var a = new Layers();
+			const a = new Layers();
 
 			a.set( 0 );
 			a.enable( 0 );
@@ -49,9 +56,15 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'enableAll', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.test( 'toggle', ( assert ) => {
 
-			var a = new Layers();
+			const a = new Layers();
 
 			a.set( 0 );
 			a.toggle( 0 );
@@ -73,7 +86,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'disable', ( assert ) => {
 
-			var a = new Layers();
+			const a = new Layers();
 
 			a.set( 0 );
 			a.disable( 0 );
@@ -93,10 +106,16 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
+		QUnit.todo( 'disableAll', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.test( 'test', ( assert ) => {
 
-			var a = new Layers();
-			var b = new Layers();
+			const a = new Layers();
+			const b = new Layers();
 
 			assert.ok( a.test( b ), 'Start out true' );
 
@@ -110,7 +129,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'isEnabled', ( assert ) => {
 
-			var a = new Layers();
+			const a = new Layers();
 
 			a.enable( 1 );
 			assert.ok( a.isEnabled( 1 ), 'Enable channel 1 and pass the QUnit.test' );

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

@@ -1,6 +1,7 @@
 /* global QUnit */
 
 import { Object3D } from '../../../../src/core/Object3D.js';
+
 import { Vector3 } from '../../../../src/math/Vector3.js';
 import { Euler } from '../../../../src/math/Euler.js';
 import { Quaternion } from '../../../../src/math/Quaternion.js';
@@ -34,9 +35,9 @@ export default QUnit.module( 'Core', () => {
 
 	QUnit.module( 'Object3D', () => {
 
-		var RadToDeg = 180 / Math.PI;
+		const RadToDeg = 180 / Math.PI;
 
-		var eulerEquals = function ( a, b, tolerance ) {
+		const eulerEquals = function ( a, b, tolerance ) {
 
 			tolerance = tolerance || 0.0001;
 
@@ -57,9 +58,11 @@ export default QUnit.module( 'Core', () => {
 		// INHERITANCE
 		QUnit.test( 'Extending', ( assert ) => {
 
-			var object = new Object3D();
-
-			assert.strictEqual( object instanceof EventDispatcher, true, 'Object3D extends from EventDispatcher' );
+			const object = new Object3D();
+			assert.strictEqual(
+				object instanceof EventDispatcher, true,
+				'Object3D extends from EventDispatcher'
+			);
 
 		} );
 
@@ -70,7 +73,168 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// STATIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'id', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'uuid', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'name', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new Object3D();
+			assert.ok(
+				object.type === 'Object3D',
+				'Object3D.type should be Object3D'
+			);
+
+		} );
+
+		QUnit.todo( 'parent', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'children', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'up', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'position', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'rotation', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'quaternion', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'scale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'modelViewMatrix', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMatrix', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'matrix', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'matrixWorld', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'matrixAutoUpdate', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'matrixWorldNeedsUpdate', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'matrixWorldAutoUpdate', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'layers', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'visible', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'castShadow', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'receiveShadow', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'frustumCulled', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'renderOrder', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'animations', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'userData', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
 		QUnit.test( 'DEFAULT_UP', ( assert ) => {
 
 			const currentDefaultUp = new Vector3().copy( Object3D.DEFAULT_UP );
@@ -108,13 +272,19 @@ export default QUnit.module( 'Core', () => {
 
 				const object = new Object3D();
 
-				assert.equal( object.matrixAutoUpdate, true, '.matrixAutoUpdate of a new object inherits Object3D.DEFAULT_MATRIX_AUTO_UPDATE = true' );
+				assert.equal(
+					object.matrixAutoUpdate, true,
+					'.matrixAutoUpdate of a new object inherits Object3D.DEFAULT_MATRIX_AUTO_UPDATE = true'
+				);
 
 				Object3D.DEFAULT_MATRIX_AUTO_UPDATE = false;
 
 				const object2 = new Object3D();
 
-				assert.equal( object2.matrixAutoUpdate, false, '.matrixAutoUpdate of a new object inherits Object3D.DEFAULT_MATRIX_AUTO_UPDATE = false' );
+				assert.equal(
+					object2.matrixAutoUpdate, false,
+					'.matrixAutoUpdate of a new object inherits Object3D.DEFAULT_MATRIX_AUTO_UPDATE = false'
+				);
 
 			} finally {
 
@@ -124,14 +294,20 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PUBLIC
 		QUnit.test( 'isObject3D', ( assert ) => {
 
 			const object = new Object3D();
-			assert.ok( object.isObject3D, 'Object3D.isObject3D should be true' );
+			assert.ok(
+				object.isObject3D,
+				'Object3D.isObject3D should be true'
+			);
 
 			const object2 = {};
-			assert.ok( object2.isObject3D === undefined, 'other object isObject3D should be undefined' );
+			assert.ok(
+				object2.isObject3D === undefined,
+				'other object isObject3D should be undefined'
+			);
 
 		} );
 
@@ -149,10 +325,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'applyMatrix4', ( assert ) => {
 
-			var a = new Object3D();
-			var m = new Matrix4();
-			var expectedPos = new Vector3( x, y, z );
-			var expectedQuat = new Quaternion( 0.5 * Math.sqrt( 2 ), 0, 0, 0.5 * Math.sqrt( 2 ) );
+			const a = new Object3D();
+			const m = new Matrix4();
+			const expectedPos = new Vector3( x, y, z );
+			const expectedQuat = new Quaternion( 0.5 * Math.sqrt( 2 ), 0, 0, 0.5 * Math.sqrt( 2 ) );
 
 			m.makeRotationX( Math.PI / 2 );
 			m.setPosition( new Vector3( x, y, z ) );
@@ -171,10 +347,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'applyQuaternion', ( assert ) => {
 
-			var a = new Object3D();
-			var sqrt = 0.5 * Math.sqrt( 2 );
-			var quat = new Quaternion( 0, sqrt, 0, sqrt );
-			var expected = new Quaternion( sqrt / 2, sqrt / 2, 0, 0 );
+			const a = new Object3D();
+			const sqrt = 0.5 * Math.sqrt( 2 );
+			const quat = new Quaternion( 0, sqrt, 0, sqrt );
+			const expected = new Quaternion( sqrt / 2, sqrt / 2, 0, 0 );
 
 			a.quaternion.set( 0.25, 0.25, 0.25, 0.25 );
 			a.applyQuaternion( quat );
@@ -190,18 +366,18 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setRotationFromAxisAngle', ( assert ) => {
 
-			var a = new Object3D();
-			var axis = new Vector3( 0, 1, 0 );
-			var angle = Math.PI;
-			var expected = new Euler( - Math.PI, 0, - Math.PI );
-			var euler = new Euler();
+			const a = new Object3D();
+			const axis = new Vector3( 0, 1, 0 );
+			let angle = Math.PI;
+			const expected = new Euler( - Math.PI, 0, - Math.PI );
+			const euler = new Euler();
 
 			a.setRotationFromAxisAngle( axis, angle );
 			euler.setFromQuaternion( a.getWorldQuaternion( new Quaternion() ) );
 			assert.ok( eulerEquals( euler, expected ), 'Correct values after rotation' );
 
 			axis.set( 1, 0, 0 );
-			var angle = 0;
+			angle = 0;
 			expected.set( 0, 0, 0 );
 
 			a.setRotationFromAxisAngle( axis, angle );
@@ -212,10 +388,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setRotationFromEuler', ( assert ) => {
 
-			var a = new Object3D();
-			var rotation = new Euler( ( 45 / RadToDeg ), 0, Math.PI );
-			var expected = rotation.clone(); // bit obvious
-			var euler = new Euler();
+			const a = new Object3D();
+			const rotation = new Euler( ( 45 / RadToDeg ), 0, Math.PI );
+			const expected = rotation.clone(); // bit obvious
+			const euler = new Euler();
 
 			a.setRotationFromEuler( rotation );
 			euler.setFromQuaternion( a.getWorldQuaternion( new Quaternion() ) );
@@ -225,12 +401,12 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setRotationFromMatrix', ( assert ) => {
 
-			var a = new Object3D();
-			var m = new Matrix4();
-			var eye = new Vector3( 0, 0, 0 );
-			var target = new Vector3( 0, 1, - 1 );
-			var up = new Vector3( 0, 1, 0 );
-			var euler = new Euler();
+			const a = new Object3D();
+			const m = new Matrix4();
+			const eye = new Vector3( 0, 0, 0 );
+			const target = new Vector3( 0, 1, - 1 );
+			const up = new Vector3( 0, 1, 0 );
+			const euler = new Euler();
 
 			m.lookAt( eye, target, up );
 			a.setRotationFromMatrix( m );
@@ -241,9 +417,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setRotationFromQuaternion', ( assert ) => {
 
-			var a = new Object3D();
-			var rotation = new Quaternion().setFromEuler( new Euler( Math.PI, 0, - Math.PI ) );
-			var euler = new Euler();
+			const a = new Object3D();
+			const rotation = new Quaternion().setFromEuler( new Euler( Math.PI, 0, - Math.PI ) );
+			const euler = new Euler();
 
 			a.setRotationFromQuaternion( rotation );
 			euler.setFromQuaternion( a.getWorldQuaternion( new Quaternion() ) );
@@ -265,9 +441,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'rotateX', ( assert ) => {
 
-			var obj = new Object3D();
-
-			var angleInRad = 1.562;
+			const obj = new Object3D();
+			const angleInRad = 1.562;
 			obj.rotateX( angleInRad );
 
 			assert.numEqual( obj.rotation.x, angleInRad, 'x is equal' );
@@ -276,9 +451,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'rotateY', ( assert ) => {
 
-			var obj = new Object3D();
-
-			var angleInRad = - 0.346;
+			const obj = new Object3D();
+			const angleInRad = - 0.346;
 			obj.rotateY( angleInRad );
 
 			assert.numEqual( obj.rotation.y, angleInRad, 'y is equal' );
@@ -287,9 +461,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'rotateZ', ( assert ) => {
 
-			var obj = new Object3D();
-
-			var angleInRad = 1;
+			const obj = new Object3D();
+			const angleInRad = 1;
 			obj.rotateZ( angleInRad );
 
 			assert.numEqual( obj.rotation.z, angleInRad, 'z is equal' );
@@ -298,8 +471,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'translateOnAxis', ( assert ) => {
 
-			var obj = new Object3D();
-
+			const obj = new Object3D();
 			obj.translateOnAxis( new Vector3( 1, 0, 0 ), 1 );
 			obj.translateOnAxis( new Vector3( 0, 1, 0 ), 1.23 );
 			obj.translateOnAxis( new Vector3( 0, 0, 1 ), - 4.56 );
@@ -314,7 +486,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'translateX', ( assert ) => {
 
-			var obj = new Object3D();
+			const obj = new Object3D();
 			obj.translateX( 1.234 );
 
 			assert.numEqual( obj.position.x, 1.234, 'x is equal' );
@@ -323,7 +495,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'translateY', ( assert ) => {
 
-			var obj = new Object3D();
+			const obj = new Object3D();
 			obj.translateY( 1.234 );
 
 			assert.numEqual( obj.position.y, 1.234, 'y is equal' );
@@ -332,7 +504,7 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'translateZ', ( assert ) => {
 
-			var obj = new Object3D();
+			const obj = new Object3D();
 			obj.translateZ( 1.234 );
 
 			assert.numEqual( obj.position.z, 1.234, 'z is equal' );
@@ -401,18 +573,18 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'lookAt', ( assert ) => {
 
-			var obj = new Object3D();
+			const obj = new Object3D();
 			obj.lookAt( new Vector3( 0, - 1, 1 ) );
 
 			assert.numEqual( obj.rotation.x * RadToDeg, 45, 'x is equal' );
 
 		} );
 
-		QUnit.test( 'add/remove/clear', ( assert ) => {
+		QUnit.test( 'add/remove/removeFromParent/clear', ( assert ) => {
 
-			var a = new Object3D();
-			var child1 = new Object3D();
-			var child2 = new Object3D();
+			const a = new Object3D();
+			const child1 = new Object3D();
+			const child2 = new Object3D();
 
 			assert.strictEqual( a.children.length, 0, 'Starts with no children' );
 
@@ -514,10 +686,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'getObjectById/getObjectByName/getObjectByProperty', ( assert ) => {
 
-			var parent = new Object3D();
-			var childName = new Object3D();
-			var childId = new Object3D(); // id = parent.id + 2
-			var childNothing = new Object3D();
+			const parent = new Object3D();
+			const childName = new Object3D();
+			const childId = new Object3D(); // id = parent.id + 2
+			const childNothing = new Object3D();
 
 			parent.prop = true;
 			childName.name = 'foo';
@@ -535,11 +707,11 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'getObjectsByProperty', ( assert ) => {
 
-			var parent = new Object3D();
-			var childName = new Object3D();
-			var childNothing = new Object3D();
-			var childName2 = new Object3D();
-			var childName3 = new Object3D();
+			const parent = new Object3D();
+			const childName = new Object3D();
+			const childNothing = new Object3D();
+			const childName2 = new Object3D();
+			const childName3 = new Object3D();
 
 			parent.prop = true;
 			childName.name = 'foo';
@@ -556,12 +728,12 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'getWorldPosition', ( assert ) => {
 
-			var a = new Object3D();
-			var b = new Object3D();
-			var expectedSingle = new Vector3( x, y, z );
-			var expectedParent = new Vector3( x, y, 0 );
-			var expectedChild = new Vector3( x, y, 7 );
-			var position = new Vector3();
+			const a = new Object3D();
+			const b = new Object3D();
+			const expectedSingle = new Vector3( x, y, z );
+			const expectedParent = new Vector3( x, y, 0 );
+			const expectedChild = new Vector3( x, y, 7 );
+			const position = new Vector3();
 
 			a.translateX( x );
 			a.translateY( y );
@@ -587,9 +759,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'getWorldScale', ( assert ) => {
 
-			var a = new Object3D();
-			var m = new Matrix4().makeScale( x, y, z );
-			var expected = new Vector3( x, y, z );
+			const a = new Object3D();
+			const m = new Matrix4().makeScale( x, y, z );
+			const expected = new Vector3( x, y, z );
 
 			a.applyMatrix4( m );
 
@@ -599,9 +771,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'getWorldDirection', ( assert ) => {
 
-			var a = new Object3D();
-			var expected = new Vector3( 0, - 0.5 * Math.sqrt( 2 ), 0.5 * Math.sqrt( 2 ) );
-			var direction = new Vector3();
+			const a = new Object3D();
+			const expected = new Vector3( 0, - 0.5 * Math.sqrt( 2 ), 0.5 * Math.sqrt( 2 ) );
+			const direction = new Vector3();
 
 			a.lookAt( new Vector3( 0, - 1, 1 ) );
 			a.getWorldDirection( direction );
@@ -617,10 +789,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'localTransformVariableInstantiation', ( assert ) => {
 
-			var a = new Object3D();
-			var b = new Object3D();
-			var c = new Object3D();
-			var d = new Object3D();
+			const a = new Object3D();
+			const b = new Object3D();
+			const c = new Object3D();
+			const d = new Object3D();
 
 			a.getWorldDirection( new Vector3() );
 			a.lookAt( new Vector3( 0, - 1, 1 ) );
@@ -652,14 +824,14 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'traverse/traverseVisible/traverseAncestors', ( assert ) => {
 
-			var a = new Object3D();
-			var b = new Object3D();
-			var c = new Object3D();
-			var d = new Object3D();
-			var names = [];
-			var expectedNormal = [ 'parent', 'child', 'childchild 1', 'childchild 2' ];
-			var expectedVisible = [ 'parent', 'child', 'childchild 2' ];
-			var expectedAncestors = [ 'child', 'parent' ];
+			const a = new Object3D();
+			const b = new Object3D();
+			const c = new Object3D();
+			const d = new Object3D();
+			let names = [];
+			const expectedNormal = [ 'parent', 'child', 'childchild 1', 'childchild 2' ];
+			const expectedVisible = [ 'parent', 'child', 'childchild 2' ];
+			const expectedAncestors = [ 'child', 'parent' ];
 
 			a.name = 'parent';
 			b.name = 'child';
@@ -678,7 +850,7 @@ export default QUnit.module( 'Core', () => {
 			} );
 			assert.deepEqual( names, expectedNormal, 'Traversed objects in expected order' );
 
-			var names = [];
+			names = [];
 			a.traverseVisible( function ( obj ) {
 
 				names.push( obj.name );
@@ -686,7 +858,7 @@ export default QUnit.module( 'Core', () => {
 			} );
 			assert.deepEqual( names, expectedVisible, 'Traversed visible objects in expected order' );
 
-			var names = [];
+			names = [];
 			c.traverseAncestors( function ( obj ) {
 
 				names.push( obj.name );
@@ -1078,9 +1250,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'toJSON', ( assert ) => {
 
-			var a = new Object3D();
-			var child = new Object3D();
-			var childChild = new Object3D();
+			const a = new Object3D();
+			const child = new Object3D();
+			const childChild = new Object3D();
 
 			a.name = 'a\'s name';
 			a.matrix.set( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 );
@@ -1094,7 +1266,7 @@ export default QUnit.module( 'Core', () => {
 			child.add( childChild );
 			a.add( child );
 
-			var gold = {
+			const gold = {
 				'metadata': {
 					'version': 4.5,
 					'type': 'Object',
@@ -1130,7 +1302,7 @@ export default QUnit.module( 'Core', () => {
 			};
 
 			// hacks
-			var out = a.toJSON();
+			const out = a.toJSON();
 			out.object.uuid = '0A1E4F43-CB5B-4097-8F82-DC2969C0B8C2';
 
 			assert.deepEqual( out, gold, 'JSON is as expected' );
@@ -1140,7 +1312,7 @@ export default QUnit.module( 'Core', () => {
 		QUnit.test( 'clone', ( assert ) => {
 
 			var a;
-			var b = new Object3D();
+			const b = new Object3D();
 
 			assert.strictEqual( a, undefined, 'Undefined pre-clone()' );
 
@@ -1154,10 +1326,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'copy', ( assert ) => {
 
-			var a = new Object3D();
-			var b = new Object3D();
-			var child = new Object3D();
-			var childChild = new Object3D();
+			const a = new Object3D();
+			const b = new Object3D();
+			const child = new Object3D();
+			const childChild = new Object3D();
 
 			a.name = 'original';
 			b.name = 'to-be-copied';

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

@@ -30,29 +30,29 @@ function getRaycaster() {
 
 function getObjectsToCheck() {
 
-	var objects = [];
+	const objects = [];
 
-	var sphere1 = getSphere();
+	const sphere1 = getSphere();
 	sphere1.position.set( 0, 0, - 10 );
 	sphere1.name = 1;
 	objects.push( sphere1 );
 
-	var sphere11 = getSphere();
+	const sphere11 = getSphere();
 	sphere11.position.set( 0, 0, 1 );
 	sphere11.name = 11;
 	sphere1.add( sphere11 );
 
-	var sphere12 = getSphere();
+	const sphere12 = getSphere();
 	sphere12.position.set( 0, 0, - 1 );
 	sphere12.name = 12;
 	sphere1.add( sphere12 );
 
-	var sphere2 = getSphere();
+	const sphere2 = getSphere();
 	sphere2.position.set( - 5, 0, - 5 );
 	sphere2.name = 2;
 	objects.push( sphere2 );
 
-	for ( var i = 0; i < objects.length; i ++ ) {
+	for ( let i = 0; i < objects.length; i ++ ) {
 
 		objects[ i ].updateMatrixWorld();
 
@@ -79,12 +79,49 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'ray', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'near', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'far', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'camera', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'layers', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'params', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
 		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() );
+			const origin = new Vector3( 0, 0, 0 );
+			const direction = new Vector3( 0, 0, - 1 );
+			const 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' );
@@ -100,9 +137,9 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setFromCamera (Perspective)', ( assert ) => {
 
-			var raycaster = new Raycaster();
-			var rayDirection = raycaster.ray.direction;
-			var camera = new PerspectiveCamera( 90, 1, 1, 1000 );
+			const raycaster = new Raycaster();
+			const rayDirection = raycaster.ray.direction;
+			const camera = new PerspectiveCamera( 90, 1, 1, 1000 );
 
 			raycaster.setFromCamera( {
 				x: 0,
@@ -111,18 +148,18 @@ export default QUnit.module( 'Core', () => {
 			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' );
 
-			var step = 0.1;
+			const step = 0.1;
 
-			for ( var x = - 1; x <= 1; x += step ) {
+			for ( let x = - 1; x <= 1; x += step ) {
 
-				for ( var y = - 1; y <= 1; y += step ) {
+				for ( let y = - 1; y <= 1; y += step ) {
 
 					raycaster.setFromCamera( {
 						x,
 						y
 					}, camera );
 
-					var refVector = new Vector3( x, y, - 1 ).normalize();
+					const refVector = new Vector3( x, y, - 1 ).normalize();
 
 					checkRayDirectionAgainstReferenceVector( rayDirection, refVector, assert );
 
@@ -134,12 +171,12 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'setFromCamera (Orthographic)', ( assert ) => {
 
-			var raycaster = new Raycaster();
-			var rayOrigin = raycaster.ray.origin;
-			var rayDirection = raycaster.ray.direction;
-			var camera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1000 );
-			var expectedOrigin = new Vector3( 0, 0, 0 );
-			var expectedDirection = new Vector3( 0, 0, - 1 );
+			const raycaster = new Raycaster();
+			const rayOrigin = raycaster.ray.origin;
+			const rayDirection = raycaster.ray.direction;
+			const camera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1000 );
+			const expectedOrigin = new Vector3( 0, 0, 0 );
+			const expectedDirection = new Vector3( 0, 0, - 1 );
 
 			raycaster.setFromCamera( {
 				x: 0,
@@ -152,8 +189,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'intersectObject', ( assert ) => {
 
-			var raycaster = getRaycaster();
-			var objectsToCheck = getObjectsToCheck();
+			const raycaster = getRaycaster();
+			const objectsToCheck = getObjectsToCheck();
 
 			assert.ok( raycaster.intersectObject( objectsToCheck[ 0 ], false ).length === 1,
 				'no recursive search should lead to one hit' );
@@ -161,8 +198,8 @@ export default QUnit.module( 'Core', () => {
 			assert.ok( raycaster.intersectObject( objectsToCheck[ 0 ] ).length === 3,
 				'recursive search should lead to three hits' );
 
-			var intersections = raycaster.intersectObject( objectsToCheck[ 0 ] );
-			for ( var i = 0; i < intersections.length - 1; i ++ ) {
+			const intersections = raycaster.intersectObject( objectsToCheck[ 0 ] );
+			for ( let i = 0; i < intersections.length - 1; i ++ ) {
 
 				assert.ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, 'intersections are sorted' );
 
@@ -172,8 +209,8 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'intersectObjects', ( assert ) => {
 
-			var raycaster = getRaycaster();
-			var objectsToCheck = getObjectsToCheck();
+			const raycaster = getRaycaster();
+			const objectsToCheck = getObjectsToCheck();
 
 			assert.ok( raycaster.intersectObjects( objectsToCheck, false ).length === 1,
 				'no recursive search should lead to one hit' );
@@ -181,8 +218,8 @@ export default QUnit.module( 'Core', () => {
 			assert.ok( raycaster.intersectObjects( objectsToCheck ).length === 3,
 				'recursive search should lead to three hits' );
 
-			var intersections = raycaster.intersectObjects( objectsToCheck );
-			for ( var i = 0; i < intersections.length - 1; i ++ ) {
+			const intersections = raycaster.intersectObjects( objectsToCheck );
+			for ( let i = 0; i < intersections.length - 1; i ++ ) {
 
 				assert.ok( intersections[ i ].distance <= intersections[ i + 1 ].distance, 'intersections are sorted' );
 
@@ -192,10 +229,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'Line intersection threshold', ( assert ) => {
 
-			var raycaster = getRaycaster();
-			var points = [ new Vector3( - 2, - 10, - 5 ), new Vector3( - 2, 10, - 5 ) ];
-			var geometry = new BufferGeometry().setFromPoints( points );
-			var line = new Line( geometry, null );
+			const raycaster = getRaycaster();
+			const points = [ new Vector3( - 2, - 10, - 5 ), new Vector3( - 2, 10, - 5 ) ];
+			const geometry = new BufferGeometry().setFromPoints( points );
+			const line = new Line( geometry, null );
 
 			raycaster.params.Line.threshold = 1.999;
 			assert.ok( raycaster.intersectObject( line ).length === 0,
@@ -209,10 +246,10 @@ export default QUnit.module( 'Core', () => {
 
 		QUnit.test( 'Points intersection threshold', ( assert ) => {
 
-			var raycaster = getRaycaster();
-			var coordinates = [ new Vector3( - 2, 0, - 5 ) ];
-			var geometry = new BufferGeometry().setFromPoints( coordinates );
-			var points = new Points( geometry, null );
+			const raycaster = getRaycaster();
+			const coordinates = [ new Vector3( - 2, 0, - 5 ) ];
+			const geometry = new BufferGeometry().setFromPoints( coordinates );
+			const points = new Points( geometry, null );
 
 			raycaster.params.Points.threshold = 1.999;
 			assert.ok( raycaster.intersectObject( points ).length === 0,
@@ -224,7 +261,6 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-
 	} );
 
 } );

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

@@ -15,8 +15,8 @@ export default QUnit.module( 'Core', () => {
 		// INSTANCING
 		QUnit.test( 'Instancing', ( assert ) => {
 
-			var a;
-			var b = new Vector3( x, y, z );
+			let a;
+			const b = new Vector3( x, y, z );
 
 			a = new Uniform( 5 );
 			assert.strictEqual( a.value, 5, 'New constructor works with simple values' );
@@ -26,16 +26,23 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'value', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
 		QUnit.test( 'clone', ( assert ) => {
 
-			var a = new Uniform( 23 );
-			var b = a.clone();
+			let a = new Uniform( 23 );
+			let b = a.clone();
 
 			assert.strictEqual( b.value, a.value, 'clone() with simple values works' );
 
-			var a = new Uniform( new Vector3( 1, 2, 3 ) );
-			var b = a.clone();
+			a = new Uniform( new Vector3( 1, 2, 3 ) );
+			b = a.clone();
 
 			assert.ok( b.value.equals( a.value ), 'clone() with complex values works' );
 

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

@@ -0,0 +1,109 @@
+/* global QUnit */
+
+import { UniformsGroup } from '../../../../src/core/UniformsGroup.js';
+
+import { EventDispatcher } from '../../../../src/core/EventDispatcher.js';
+
+export default QUnit.module( 'Core', () => {
+
+	QUnit.module( 'UniformsGroup', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			const object = new UniformsGroup();
+			assert.strictEqual(
+				object instanceof EventDispatcher, true,
+				'UniformsGroup extends from EventDispatcher'
+			);
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PROPERTIES
+		QUnit.todo( 'id', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'name', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'usage', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'uniforms', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isUniformsGroup', ( assert ) => {
+
+			const object = new UniformsGroup();
+			assert.ok(
+				object.isUniformsGroup,
+				'UniformsGroup.isUniformsGroup should be true'
+			);
+
+		} );
+
+		QUnit.todo( 'add', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'remove', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setName', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setUsage', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'dispose', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'copy', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clone', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

test/unit/three.source.unit.js

@@ -47,6 +47,7 @@ import './src/core/BufferAttribute.tests.js';
 import './src/core/BufferGeometry.tests.js';
 import './src/core/Clock.tests.js';
 import './src/core/EventDispatcher.tests.js';
+import './src/core/GLBufferAttribute.tests.js';
 import './src/core/InstancedBufferAttribute.tests.js';
 import './src/core/InstancedBufferGeometry.tests.js';
 import './src/core/InstancedInterleavedBuffer.tests.js';
@@ -56,6 +57,7 @@ import './src/core/Layers.tests.js';
 import './src/core/Object3D.tests.js';
 import './src/core/Raycaster.tests.js';
 import './src/core/Uniform.tests.js';
+import './src/core/UniformsGroup.tests.js';
 
 
 //src/extras