Tests: Unit Tests for Materials (#25388)

* Add MeshMatcapMaterial unit test.

Add MeshMatcapMaterial unit test.

* Update LineDashedMaterial.tests.js

LineDashedMaterial extends from Material
LineDashedMaterial.type should be LineDashedMaterial
LineDashedMaterial.isLineDashedMaterial should be true
Stub missing member tests.

* Update LineBasicMaterial.tests.js

LineBasicMaterial extends from Material
LineBasicMaterial.type should be LineBasicMaterial.
LineBasicMaterial.isLineBasicMaterial should be true
Stub missing member tests.

* Update Material.tests.js

Material extends from EventDispatcher.
Material.type should be Material.
Material.isMaterial should be true.
Stub missing member tests.

* Update MeshBasicMaterial.tests.js

MeshBasicMaterial extends from Material.
MeshBasicMaterial.type should be MeshBasicMaterial.
MeshBasicMaterial.isMeshBasicMaterial should be true
Stub missing member tests.

* Update MeshDepthMaterial.tests.js

MeshDepthMaterial extends from Material.
MeshDepthMaterial.type should be MeshDepthMaterial.
MeshDepthMaterial.isMeshDepthMaterial should be true.
Stub missing member tests.

* Update MeshDistanceMaterial.tests.js

MeshDistanceMaterial extends from Material.
MeshDistanceMaterial.type should be MeshDistanceMaterial.
MeshDistanceMaterial.isMeshDistanceMaterial should be true.
Stub missing member tests.

* Update MeshLambertMaterial.tests.js

MeshLambertMaterial extends from Material.
MeshLambertMaterial.type should be MeshLambertMaterial.
MeshLambertMaterial.isMeshLambertMaterial should be true.
Stub missing member tests.

* Update MeshNormalMaterial.tests.js

MeshNormalMaterial extends from Material.
MeshNormalMaterial.type should be MeshNormalMaterial.
MeshNormalMaterial.isMeshNormalMaterial should be true.
Stub missing member tests.

* Update MeshPhongMaterial.tests.js

MeshPhongMaterial extends from Material.
MeshPhongMaterial.type should be MeshPhongMaterial.
MeshPhongMaterial.isMeshPhongMaterial should be true.
Stub missing member tests.

* Update MeshPhysicalMaterial.tests.js

MeshPhysicalMaterial extends from Material.
MeshPhysicalMaterial.type should be MeshPhysicalMaterial.
MeshPhysicalMaterial.isMeshPhysicalMaterial should be true.
Stub missing member tests.

* Update MeshStandardMaterial.tests.js

MeshStandardMaterial extends from Material.
MeshStandardMaterial.type should be MeshStandardMaterial.
MeshStandardMaterial.isMeshStandardMaterial should be true.
Stub missing member tests.

* Update MeshToonMaterial.tests.js

MeshToonMaterial extends from Material.
MeshToonMaterial.type should be MeshToonMaterial.
MeshToonMaterial.isMeshToonMaterial should be true.
Stub missing member tests.

* Update PointsMaterial.tests.js

PointsMaterial extends from Material.
PointsMaterial.type should be PointsMaterial.
PointsMaterial.isPointsMaterial should be true.
Stub missing member tests.

* Update RawShaderMaterial.tests.js

RawShaderMaterial extends from ShaderMaterial.
RawShaderMaterial.type should be RawShaderMaterial.
RawShaderMaterial.isRawShaderMaterial should be true.

* Update ShaderMaterial.tests.js

ShaderMaterial extends from Material.
ShaderMaterial.type should be ShaderMaterial.
ShaderMaterial.isShaderMaterial should be true.
Stub missing member tests.

* Update ShadowMaterial.tests.js

ShadowMaterial extends from Material.
ShadowMaterial.type should be ShadowMaterial.
ShadowMaterial.isShadowMaterial should be true.
Stub missing member tests.

* Update SpriteMaterial.tests.js

SpriteMaterial extends from Material.
SpriteMaterial.type should be SpriteMaterial.
SpriteMaterial.isSpriteMaterial should be true.
Stub missing member tests.

test/unit/src/materials/LineBasicMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { LineBasicMaterial } from '../../../../src/materials/LineBasicMaterial.js';
+import { LineBasicMaterial } from '../../../../src/materials/LineBasicMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'LineBasicMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new LineBasicMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'LineBasicMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,58 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isLineBasicMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new LineBasicMaterial();
+			assert.ok(
+				object.type === 'LineBasicMaterial',
+				'LineBasicMaterial.type should be LineBasicMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'linewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'linecap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'linejoin', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isLineBasicMaterial', ( assert ) => {
+
+			const object = new LineBasicMaterial();
+			assert.ok(
+				object.isLineBasicMaterial,
+				'LineBasicMaterial.isLineBasicMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/LineDashedMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { LineDashedMaterial } from '../../../../src/materials/LineDashedMaterial.js';
+import { LineDashedMaterial } from '../../../../src/materials/LineDashedMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'LineDashedMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new LineDashedMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'LineDashedMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,46 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isLineDashedMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new LineDashedMaterial();
+			assert.ok(
+				object.type === 'LineDashedMaterial',
+				'LineDashedMaterial.type should be LineDashedMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'scale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'dashSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'gapSize', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		// PUBLIC
+		QUnit.test( 'isLineDashedMaterial', ( assert ) => {
+
+			const object = new LineDashedMaterial();
+			assert.ok(
+				object.isLineDashedMaterial,
+				'LineDashedMaterial.isLineDashedMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/Material.tests.js

@@ -1,11 +1,24 @@
 /* global QUnit */
 
-// import { Material } from '../../../../src/materials/Material.js';
+import { Material } from '../../../../src/materials/Material.js';
+
+import { EventDispatcher } from '../../../../src/core/EventDispatcher.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'Material', () => {
 
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			const object = new Material();
+			assert.strictEqual(
+				object instanceof EventDispatcher, true,
+				'Material extends from EventDispatcher'
+			);
+
+		} );
+
 		// INSTANCING
 		QUnit.todo( 'Instancing', ( assert ) => {
 
@@ -13,8 +26,295 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMaterial', ( 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 Material();
+			assert.ok(
+				object.type === 'Material',
+				'Material.type should be Material'
+			);
+
+		} );
+
+		QUnit.todo( 'blending', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'side', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'vertexColors', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'opacity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transparent', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'blendSrc', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'blendDst', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'blendEquation', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'blendSrcAlpha', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'blendDstAlpha', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'blendEquationAlpha', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'depthFunc', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'depthTest', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'depthWrite', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilWriteMask', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilFunc', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilRef', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilFuncMask', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilFail', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilZFail', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilZPass', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilWrite', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clippingPlanes', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clipIntersection', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clipShadows', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'shadowSide', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'colorWrite', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'precision', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'polygonOffset', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'polygonOffsetFactor', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'polygonOffsetUnits', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'dithering', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaToCoverage', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'premultipliedAlpha', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'forceSinglePass', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'visible', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'toneMapped', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'userData', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+
+		QUnit.todo( 'alphaTest', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'needsUpdate', ( assert ) => {
+
+			// set needsUpdate
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMaterial', ( assert ) => {
+
+			const object = new Material();
+			assert.ok(
+				object.isMaterial,
+				'Material.isMaterial should be true'
+			);
+
+		} );
+
+		QUnit.todo( 'onBuild', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'onBeforeRender', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
@@ -26,6 +326,12 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
+		QUnit.todo( 'customProgramCacheKey', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		QUnit.todo( 'setValues', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshBasicMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshBasicMaterial } from '../../../../src/materials/MeshBasicMaterial.js';
+import { MeshBasicMaterial } from '../../../../src/materials/MeshBasicMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshBasicMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshBasicMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshBasicMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,130 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshBasicMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshBasicMaterial();
+			assert.ok(
+				object.type === 'MeshBasicMaterial',
+				'MeshBasicMaterial.type should be MeshBasicMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'envMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'combine', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'reflectivity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'refractionRatio', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinecap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinejoin', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshBasicMaterial', ( assert ) => {
+
+			const object = new MeshBasicMaterial();
+			assert.ok(
+				object.isMeshBasicMaterial,
+				'MeshBasicMaterial.isMeshBasicMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshDepthMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshDepthMaterial } from '../../../../src/materials/MeshDepthMaterial.js';
+import { MeshDepthMaterial } from '../../../../src/materials/MeshDepthMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshDepthMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshDepthMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshDepthMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,76 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshDepthMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshDepthMaterial();
+			assert.ok(
+				object.type === 'MeshDepthMaterial',
+				'MeshDepthMaterial.type should be MeshDepthMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'depthPacking', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshDepthMaterial', ( assert ) => {
+
+			const object = new MeshDepthMaterial();
+			assert.ok(
+				object.isMeshDepthMaterial,
+				'MeshDepthMaterial.isMeshDepthMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshDistanceMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshDistanceMaterial } from '../../../../src/materials/MeshDistanceMaterial.js';
+import { MeshDistanceMaterial } from '../../../../src/materials/MeshDistanceMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshDistanceMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshDistanceMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshDistanceMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,76 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshDistanceMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshDistanceMaterial();
+			assert.ok(
+				object.type === 'MeshDistanceMaterial',
+				'MeshDistanceMaterial.type should be MeshDistanceMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'referencePosition', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'nearDistance', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'farDistance', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshDistanceMaterial', ( assert ) => {
+
+			const object = new MeshDistanceMaterial();
+			assert.ok(
+				object.isMeshDistanceMaterial,
+				'MeshDistanceMaterial.isMeshDistanceMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshLambertMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshLambertMaterial } from '../../../../src/materials/MeshLambertMaterial.js';
+import { MeshLambertMaterial } from '../../../../src/materials/MeshLambertMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshLambertMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshLambertMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshLambertMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,202 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshLambertMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshLambertMaterial();
+			assert.ok(
+				object.type === 'MeshLambertMaterial',
+				'MeshLambertMaterial.type should be MeshLambertMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissive', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMapType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'envMap', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'combine', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'reflectivity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'refractionRatio', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinecap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinejoin', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'flatShading', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshLambertMaterial', ( assert ) => {
+
+			const object = new MeshLambertMaterial();
+			assert.ok(
+				object.isMeshLambertMaterial,
+				'MeshLambertMaterial.isMeshLambertMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshMatcapMaterial.tests.js

@@ -0,0 +1,152 @@
+/* global QUnit */
+
+import { MeshMatcapMaterial } from '../../../../src/materials/MeshMatcapMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
+
+export default QUnit.module( 'Materials', () => {
+
+	QUnit.module( 'MeshMatcapMaterial', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			const object = new MeshMatcapMaterial();
+
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshMatcapMaterial extends from Material'
+			);
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PROPERTIES
+		QUnit.test( 'defines', ( assert ) => {
+
+			const actual = new MeshMatcapMaterial().defines;
+			const expected = { 'MATCAP': '' };
+			assert.deepEqual( actual, expected, 'Contains a MATCAP definition.' );
+
+		} );
+
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshMatcapMaterial();
+			assert.ok(
+				object.type === 'MeshMatcapMaterial',
+				'MeshMatcapMaterial.type should be MeshMatcapMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'matcap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMapType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'flatShading', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshMatcapMaterial', ( assert ) => {
+
+			const object = new MeshMatcapMaterial();
+			assert.ok(
+				object.isMeshMatcapMaterial,
+				'MeshMatcapMaterial.isMeshMatcapMaterial should be true'
+			);
+
+		} );
+
+		QUnit.todo( 'copy', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

test/unit/src/materials/MeshNormalMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshNormalMaterial } from '../../../../src/materials/MeshNormalMaterial.js';
+import { MeshNormalMaterial } from '../../../../src/materials/MeshNormalMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshNormalMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshNormalMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshNormalMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,94 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshNormalMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshNormalMaterial();
+			assert.ok(
+				object.type === 'MeshNormalMaterial',
+				'MeshNormalMaterial.type should be MeshNormalMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'bumpMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMapType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'flatShading', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshNormalMaterial', ( assert ) => {
+
+			const object = new MeshNormalMaterial();
+			assert.ok(
+				object.isMeshNormalMaterial,
+				'MeshNormalMaterial.isMeshNormalMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshPhongMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshPhongMaterial } from '../../../../src/materials/MeshPhongMaterial.js';
+import { MeshPhongMaterial } from '../../../../src/materials/MeshPhongMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshPhongMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshPhongMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshPhongMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,214 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshPhongMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshPhongMaterial();
+			assert.ok(
+				object.type === 'MeshPhongMaterial',
+				'MeshPhongMaterial.type should be MeshPhongMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specular', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'shininess', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissive', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMapType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'envMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'combine', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'reflectivity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'refractionRatio', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinecap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinejoin', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'flatShading', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		// PUBLIC
+		QUnit.test( 'isMeshPhongMaterial', ( assert ) => {
+
+			const object = new MeshPhongMaterial();
+			assert.ok(
+				object.isMeshPhongMaterial,
+				'MeshPhongMaterial.isMeshPhongMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshPhysicalMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshPhysicalMaterial } from '../../../../src/materials/MeshPhysicalMaterial.js';
+import { MeshPhysicalMaterial } from '../../../../src/materials/MeshPhysicalMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshPhysicalMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshPhysicalMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshPhysicalMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,202 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshPhysicalMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.todo( 'defines', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshPhysicalMaterial();
+			assert.ok(
+				object.type === 'MeshPhysicalMaterial',
+				'MeshPhysicalMaterial.type should be MeshPhysicalMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'clearcoatMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clearcoatRoughness', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clearcoatRoughnessMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clearcoatNormalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clearcoatNormalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'ior', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'reflectivity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'iridescenceMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'iridescenceIOR', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'iridescenceThicknessRange', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'iridescenceThicknessMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sheenColor', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sheenColorMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sheenRoughness', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sheenRoughnessMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transmissionMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'thickness', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'thicknessMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'attenuationDistance', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'attenuationColor', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularIntensityMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularColor', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'specularColorMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sheen', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clearcoat', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'iridescence', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transmission', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshPhysicalMaterial', ( assert ) => {
+
+			const object = new MeshPhysicalMaterial();
+			assert.ok(
+				object.isMeshPhysicalMaterial,
+				'MeshPhysicalMaterial.isMeshPhysicalMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshStandardMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshStandardMaterial } from '../../../../src/materials/MeshStandardMaterial.js';
+import { MeshStandardMaterial } from '../../../../src/materials/MeshStandardMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshStandardMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshStandardMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshStandardMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,215 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshStandardMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.todo( 'defines', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshStandardMaterial();
+			assert.ok(
+				object.type === 'MeshStandardMaterial',
+				'MeshStandardMaterial.type should be MeshStandardMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			// diffuse color
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'roughness', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'metalness', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissive', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMapType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'roughnessMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'metalnessMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'envMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'envMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinecap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinejoin', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'flatShading', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		// PUBLIC
+		QUnit.test( 'isMeshStandardMaterial', ( assert ) => {
+
+			const object = new MeshStandardMaterial();
+			assert.ok(
+				object.isMeshStandardMaterial,
+				'MeshStandardMaterial.isMeshStandardMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/MeshToonMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { MeshToonMaterial } from '../../../../src/materials/MeshToonMaterial.js';
+import { MeshToonMaterial } from '../../../../src/materials/MeshToonMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'MeshToonMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new MeshToonMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'MeshToonMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,178 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isMeshToonMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.todo( 'defines', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new MeshToonMaterial();
+			assert.ok(
+				object.type === 'MeshToonMaterial',
+				'MeshToonMaterial.type should be MeshToonMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'gradientMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lightMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'aoMapIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissive', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveIntensity', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'emissiveMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'bumpScale', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'normalMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalMapType', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normalScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementScale', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'displacementBias', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinecap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinejoin', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isMeshToonMaterial', ( assert ) => {
+
+			const object = new MeshToonMaterial();
+			assert.ok(
+				object.isMeshToonMaterial,
+				'MeshToonMaterial.isMeshToonMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/PointsMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { PointsMaterial } from '../../../../src/materials/PointsMaterial.js';
+import { PointsMaterial } from '../../../../src/materials/PointsMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'PointsMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new PointsMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'PointsMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,64 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isPointsMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new PointsMaterial();
+			assert.ok(
+				object.type === 'PointsMaterial',
+				'PointsMaterial.type should be PointsMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'size', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sizeAttenuation', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isPointsMaterial', ( assert ) => {
+
+			const object = new PointsMaterial();
+			assert.ok(
+				object.isPointsMaterial,
+				'PointsMaterial.isPointsMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/RawShaderMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { RawShaderMaterial } from '../../../../src/materials/RawShaderMaterial.js';
+import { RawShaderMaterial } from '../../../../src/materials/RawShaderMaterial.js';
+
+import { ShaderMaterial } from '../../../../src/materials/ShaderMaterial.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'RawShaderMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new RawShaderMaterial();
+			assert.strictEqual(
+				object instanceof ShaderMaterial, true,
+				'RawShaderMaterial extends from ShaderMaterial'
+			);
 
 		} );
 
@@ -20,10 +26,25 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isRawShaderMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new RawShaderMaterial();
+			assert.ok(
+				object.type === 'RawShaderMaterial',
+				'RawShaderMaterial.type should be RawShaderMaterial'
+			);
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isRawShaderMaterial', ( assert ) => {
+
+			const object = new RawShaderMaterial();
+			assert.ok(
+				object.isRawShaderMaterial,
+				'RawShaderMaterial.isRawShaderMaterial should be true'
+			);
 
 		} );
 

test/unit/src/materials/ShaderMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { ShaderMaterial } from '../../../../src/materials/ShaderMaterial.js';
+import { ShaderMaterial } from '../../../../src/materials/ShaderMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'ShaderMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new ShaderMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'ShaderMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,124 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isShaderwMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new ShaderMaterial();
+			assert.ok(
+				object.type === 'ShaderMaterial',
+				'ShaderMaterial.type should be ShaderMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'defines', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'uniforms', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'uniformsGroups', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'vertexShader', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fragmentShader', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'linewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframe', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'wireframeLinewidth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'lights', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clipping', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'extensions', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'defaultAttributeValues', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'index0AttributeName', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'uniformsNeedUpdate', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'glslVersion', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isShaderMaterial', ( assert ) => {
+
+			const object = new ShaderMaterial();
+			assert.ok(
+				object.isShaderMaterial,
+				'ShaderMaterial.isShaderMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/materials/ShadowMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { ShadowMaterial } from '../../../../src/materials/ShadowMaterial.js';
+import { ShadowMaterial } from '../../../../src/materials/ShadowMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
-	QUnit.module( 'LineBasicMaterial', () => {
+	QUnit.module( 'ShadowMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new ShadowMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'ShadowMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,8 +26,47 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isShadowMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new ShadowMaterial();
+			assert.ok(
+				object.type === 'ShadowMaterial',
+				'ShadowMaterial.type should be ShadowMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transparent', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.test( 'isShadowMaterial', ( assert ) => {
+
+			const object = new ShadowMaterial();
+			assert.ok(
+				object.isShadowMaterial,
+				'ShadowMaterial.isShadowMaterial should be true'
+			);
+
+		} );
+
+		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 

test/unit/src/materials/SpriteMaterial.tests.js

@@ -1,15 +1,21 @@
 /* global QUnit */
 
-// import { SpriteMaterial } from '../../../../src/materials/SpriteMaterial.js';
+import { SpriteMaterial } from '../../../../src/materials/SpriteMaterial.js';
+
+import { Material } from '../../../../src/materials/Material.js';
 
 export default QUnit.module( 'Materials', () => {
 
 	QUnit.module( 'SpriteMaterial', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new SpriteMaterial();
+			assert.strictEqual(
+				object instanceof Material, true,
+				'SpriteMaterial extends from Material'
+			);
 
 		} );
 
@@ -20,13 +26,70 @@ export default QUnit.module( 'Materials', () => {
 
 		} );
 
-		// PUBLIC STUFF
-		QUnit.todo( 'isSpriteMaterial', ( assert ) => {
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new SpriteMaterial();
+			assert.ok(
+				object.type === 'SpriteMaterial',
+				'SpriteMaterial.type should be SpriteMaterial'
+			);
+
+		} );
+
+		QUnit.todo( 'color', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'map', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'alphaMap', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'rotation', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'sizeAttenuation', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'transparent', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'fog', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		// PUBLIC
+		QUnit.test( 'isSpriteMaterial', ( assert ) => {
+
+			const object = new SpriteMaterial();
+			assert.ok(
+				object.isSpriteMaterial,
+				'SpriteMaterial.isSpriteMaterial should be true'
+			);
+
+		} );
+
 		QUnit.todo( 'copy', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/three.source.unit.js

@@ -161,6 +161,7 @@ import './src/materials/MeshBasicMaterial.tests.js';
 import './src/materials/MeshDepthMaterial.tests.js';
 import './src/materials/MeshDistanceMaterial.tests.js';
 import './src/materials/MeshLambertMaterial.tests.js';
+import './src/materials/MeshMatcapMaterial.tests.js';
 import './src/materials/MeshNormalMaterial.tests.js';
 import './src/materials/MeshPhongMaterial.tests.js';
 import './src/materials/MeshPhysicalMaterial.tests.js';