Tests: Unit Tests for Renderers (#25369)

* Update WebGLRenderer.tests.js

Remove constant definitions comment, add missing member test stubs.  In the current test framework, this needs to keep "-webonly" test module suffix.

* Update WebGLRenderTarget.tests.js

WebGLRenderTarget extends from EventDispatcher.  Add missing member test stubs.

* Update WebGLCubeRenderTarget.tests.js

WebGLCubeRenderTarget extends from WebGLRenderTarget.  Add missing member test stubs.

* Add unit tests for WebGLMultipleRenderTargets

Add unit tests for WebGLMultipleRenderTargets.

* Add unit tests for WebGLArrayRenderTarget.

Add unit tests for WebGLArrayRenderTarget.

* Add unit tests for WebGL3DRenderTarget.

Add unit tests for WebGL3DRenderTarget.

* Add unit tests for WebGL1Renderer.

Add unit tests for WebGL1Renderer. In the current test framework, this needs to keep "-webonly" test module suffix.

* Update ShaderChunk.tests.js

ShaderChunk is defined.

* Update ShaderLib.tests.js

ShaderLib is defined.

* Update UniformsLib.tests.js

UniformsLib is defined. UniformsLib does not have a 'merge' or 'clone' method.

* Update UniformsUtils.tests.js

UniformsUtils is defined.

* Update UniformsUtils.tests.js

Add legacy and public exports.

test/unit/src/renderers/WebGL1Renderer.tests.js

@@ -0,0 +1,36 @@
+/* global QUnit */
+
+import { WebGL1Renderer } from '../../../../src/renderers/WebGL1Renderer.js';
+
+import { WebGLRenderer } from '../../../../src/renderers/WebGLRenderer.js';
+
+export default QUnit.module( 'Renderers', () => {
+
+	QUnit.module( 'WebGL1Renderer-webonly', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			var object = new WebGL1Renderer();
+
+			assert.strictEqual( object instanceof WebGLRenderer, true, 'WebGL1Renderer extends from WebGLRenderer' );
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'isWebGL1Renderer', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

test/unit/src/renderers/WebGL3DRenderTarget.tests.js

@@ -0,0 +1,50 @@
+/* global QUnit */
+
+import { WebGL3DRenderTarget } from '../../../../src/renderers/WebGL3DRenderTarget.js';
+
+import { WebGLRenderTarget } from '../../../../src/renderers/WebGLRenderTarget.js';
+
+export default QUnit.module( 'Renderers', () => {
+
+	QUnit.module( 'WebGL3DRenderTarget', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			var object = new WebGL3DRenderTarget();
+
+			assert.strictEqual( object instanceof WebGLRenderTarget, true, 'WebGL3DRenderTarget extends from WebGLRenderTarget' );
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PROPERTIES
+		QUnit.todo( 'depth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'texture', ( assert ) => {
+
+			// must be Data3DTexture
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'isWebGL3DRenderTarget', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

test/unit/src/renderers/WebGLArrayRenderTarget.tests.js

@@ -0,0 +1,50 @@
+/* global QUnit */
+
+import { WebGLArrayRenderTarget } from '../../../../src/renderers/WebGLArrayRenderTarget.js';
+
+import { WebGLRenderTarget } from '../../../../src/renderers/WebGLRenderTarget.js';
+
+export default QUnit.module( 'Renderers', () => {
+
+	QUnit.module( 'WebGLArrayRenderTarget', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			var object = new WebGLArrayRenderTarget();
+
+			assert.strictEqual( object instanceof WebGLRenderTarget, true, 'WebGLArrayRenderTarget extends from WebGLRenderTarget' );
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PROPERTIES
+		QUnit.todo( 'depth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'texture', ( assert ) => {
+
+			// must be DataArrayTexture
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'isWebGLArrayRenderTarget', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

test/unit/src/renderers/WebGLCubeRenderTarget.tests.js

@@ -1,11 +1,22 @@
 /* global QUnit */
 
-// import { WebGLCubeRenderTarget } from '../../../../src/renderers/WebGLCubeRenderTarget.js';
+import { WebGLCubeRenderTarget } from '../../../../src/renderers/WebGLCubeRenderTarget.js';
+
+import { WebGLRenderTarget } from '../../../../src/renderers/WebGLRenderTarget.js';
 
 export default QUnit.module( 'Renderers', () => {
 
 	QUnit.module( 'WebGLCubeRenderTarget', () => {
 
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			var object = new WebGLCubeRenderTarget();
+
+			assert.strictEqual( object instanceof WebGLRenderTarget, true, 'WebGLCubeRenderTarget extends from WebGLRenderTarget' );
+
+		} );
+
 		// INSTANCING
 		QUnit.todo( 'Instancing', ( assert ) => {
 
@@ -13,13 +24,33 @@ export default QUnit.module( 'Renderers', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'texture', ( assert ) => {
+
+			// doc update needed, this needs to be a CubeTexture unlike parent class
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
 		QUnit.todo( 'isWebGLCubeRenderTarget', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 
+		QUnit.todo( 'fromEquirectangularTexture', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'clear', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 	} );
 
 } );

test/unit/src/renderers/WebGLMultipleRenderTargets.tests.js

@@ -0,0 +1,56 @@
+/* global QUnit */
+
+import { WebGLMultipleRenderTargets } from '../../../../src/renderers/WebGLMultipleRenderTargets.js';
+
+import { WebGLRenderTarget } from '../../../../src/renderers/WebGLRenderTarget.js';
+
+export default QUnit.module( 'Renderers', () => {
+
+	QUnit.module( 'WebGLMultipleRenderTargets', () => {
+
+		// INHERITANCE
+		QUnit.test( 'Extending', ( assert ) => {
+
+			var object = new WebGLMultipleRenderTargets();
+
+			assert.strictEqual( object instanceof WebGLRenderTarget, true, 'WebGLMultipleRenderTargets extends from WebGLRenderTarget' );
+
+		} );
+
+		// INSTANCING
+		QUnit.todo( 'Instancing', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PROPERTIES
+		QUnit.todo( 'texture', ( assert ) => {
+
+			// must be Array of texture
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'isWebGLMultipleRenderTargets', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setSize', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'copy', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+	} );
+
+} );

test/unit/src/renderers/WebGLRenderTarget.tests.js

@@ -1,15 +1,19 @@
 /* global QUnit */
 
-// import { WebGLRenderTarget } from '../../../../src/renderers/WebGLRenderTarget.js';
+import { WebGLRenderTarget } from '../../../../src/renderers/WebGLRenderTarget.js';
+
+import { EventDispatcher } from '../../../../src/core/EventDispatcher.js';
 
 export default QUnit.module( 'Renderers', () => {
 
 	QUnit.module( 'WebGLRenderTarget', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			var object = new WebGLRenderTarget();
+
+			assert.strictEqual( object instanceof EventDispatcher, true, 'WebGLRenderTarget extends from EventDispatcher' );
 
 		} );
 
@@ -20,7 +24,74 @@ export default QUnit.module( 'Renderers', () => {
 
 		} );
 
-		// PUBLIC STUFF
+		// PROPERTIES
+		QUnit.todo( 'width', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'height', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'depth', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'scissor', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'scissorTest', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'viewport', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'texture', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'depthBuffer', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'stencilBuffer', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'depthTexture', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'samples', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
 		QUnit.todo( 'isWebGLRenderTarget', ( assert ) => {
 
 			assert.ok( false, 'everything\'s gonna be alright' );

test/unit/src/renderers/WebGLRenderer.tests.js

@@ -1,599 +1,371 @@
 /* global QUnit */
 
 import { WebGLRenderer } from '../../../../src/renderers/WebGLRenderer.js';
-/*
-var customWebGLContext = function () {
-
-	this.DEPTH_BUFFER_BIT = 256;
-	this.STENCIL_BUFFER_BIT = 1024;
-	this.COLOR_BUFFER_BIT = 16384;
-	this.POINTS = 0;
-	this.LINES = 1;
-	this.LINE_LOOP = 2;
-	this.LINE_STRIP = 3;
-	this.TRIANGLES = 4;
-	this.TRIANGLE_STRIP = 5;
-	this.TRIANGLE_FAN = 6;
-	this.ZERO = 0;
-	this.ONE = 1;
-	this.SRC_COLOR = 768;
-	this.ONE_MINUS_SRC_COLOR = 769;
-	this.SRC_ALPHA = 770;
-	this.ONE_MINUS_SRC_ALPHA = 771;
-	this.DST_ALPHA = 772;
-	this.ONE_MINUS_DST_ALPHA = 773;
-	this.DST_COLOR = 774;
-	this.ONE_MINUS_DST_COLOR = 775;
-	this.SRC_ALPHA_SATURATE = 776;
-	this.FUNC_ADD = 32774;
-	this.BLEND_EQUATION = 32777;
-	this.BLEND_EQUATION_RGB = 32777;
-	this.BLEND_EQUATION_ALPHA = 34877;
-	this.FUNC_SUBTRACT = 32778;
-	this.FUNC_REVERSE_SUBTRACT = 32779;
-	this.BLEND_DST_RGB = 32968;
-	this.BLEND_SRC_RGB = 32969;
-	this.BLEND_DST_ALPHA = 32970;
-	this.BLEND_SRC_ALPHA = 32971;
-	this.CONSTANT_COLOR = 32769;
-	this.ONE_MINUS_CONSTANT_COLOR = 32770;
-	this.CONSTANT_ALPHA = 32771;
-	this.ONE_MINUS_CONSTANT_ALPHA = 32772;
-	this.BLEND_COLOR = 32773;
-	this.ARRAY_BUFFER = 34962;
-	this.ELEMENT_ARRAY_BUFFER = 34963;
-	this.ARRAY_BUFFER_BINDING = 34964;
-	this.ELEMENT_ARRAY_BUFFER_BINDING = 34965;
-	this.STREAM_DRAW = 35040;
-	this.STATIC_DRAW = 35044;
-	this.DYNAMIC_DRAW = 35048;
-	this.BUFFER_SIZE = 34660;
-	this.BUFFER_USAGE = 34661;
-	this.CURRENT_VERTEX_ATTRIB = 34342;
-	this.FRONT = 1028;
-	this.BACK = 1029;
-	this.FRONT_AND_BACK = 1032;
-	this.TEXTURE_2D = 3553;
-	this.CULL_FACE = 2884;
-	this.BLEND = 3042;
-	this.DITHER = 3024;
-	this.STENCIL_TEST = 2960;
-	this.DEPTH_TEST = 2929;
-	this.SCISSOR_TEST = 3089;
-	this.POLYGON_OFFSET_FILL = 32823;
-	this.SAMPLE_ALPHA_TO_COVERAGE = 32926;
-	this.SAMPLE_COVERAGE = 32928;
-	this.NO_ERROR = 0;
-	this.INVALID_ENUM = 1280;
-	this.INVALID_VALUE = 1281;
-	this.INVALID_OPERATION = 1282;
-	this.OUT_OF_MEMORY = 1285;
-	this.CW = 2304;
-	this.CCW = 2305;
-	this.LINE_WIDTH = 2849;
-	this.ALIASED_POINT_SIZE_RANGE = 33901;
-	this.ALIASED_LINE_WIDTH_RANGE = 33902;
-	this.CULL_FACE_MODE = 2885;
-	this.FRONT_FACE = 2886;
-	this.DEPTH_RANGE = 2928;
-	this.DEPTH_WRITEMASK = 2930;
-	this.DEPTH_CLEAR_VALUE = 2931;
-	this.DEPTH_FUNC = 2932;
-	this.STENCIL_CLEAR_VALUE = 2961;
-	this.STENCIL_FUNC = 2962;
-	this.STENCIL_FAIL = 2964;
-	this.STENCIL_PASS_DEPTH_FAIL = 2965;
-	this.STENCIL_PASS_DEPTH_PASS = 2966;
-	this.STENCIL_REF = 2967;
-	this.STENCIL_VALUE_MASK = 2963;
-	this.STENCIL_WRITEMASK = 2968;
-	this.STENCIL_BACK_FUNC = 34816;
-	this.STENCIL_BACK_FAIL = 34817;
-	this.STENCIL_BACK_PASS_DEPTH_FAIL = 34818;
-	this.STENCIL_BACK_PASS_DEPTH_PASS = 34819;
-	this.STENCIL_BACK_REF = 36003;
-	this.STENCIL_BACK_VALUE_MASK = 36004;
-	this.STENCIL_BACK_WRITEMASK = 36005;
-	this.VIEWPORT = 2978;
-	this.SCISSOR_BOX = 3088;
-	this.COLOR_CLEAR_VALUE = 3106;
-	this.COLOR_WRITEMASK = 3107;
-	this.UNPACK_ALIGNMENT = 3317;
-	this.PACK_ALIGNMENT = 3333;
-	this.MAX_TEXTURE_SIZE = 3379;
-	this.MAX_VIEWPORT_DIMS = 3386;
-	this.SUBPIXEL_BITS = 3408;
-	this.RED_BITS = 3410;
-	this.GREEN_BITS = 3411;
-	this.BLUE_BITS = 3412;
-	this.ALPHA_BITS = 3413;
-	this.DEPTH_BITS = 3414;
-	this.STENCIL_BITS = 3415;
-	this.POLYGON_OFFSET_UNITS = 10752;
-	this.POLYGON_OFFSET_FACTOR = 32824;
-	this.TEXTURE_BINDING_2D = 32873;
-	this.SAMPLE_BUFFERS = 32936;
-	this.SAMPLES = 32937;
-	this.SAMPLE_COVERAGE_VALUE = 32938;
-	this.SAMPLE_COVERAGE_INVERT = 32939;
-	this.COMPRESSED_TEXTURE_FORMATS = 34467;
-	this.DONT_CARE = 4352;
-	this.FASTEST = 4353;
-	this.NICEST = 4354;
-	this.GENERATE_MIPMAP_HINT = 33170;
-	this.BYTE = 5120;
-	this.UNSIGNED_BYTE = 5121;
-	this.SHORT = 5122;
-	this.UNSIGNED_SHORT = 5123;
-	this.INT = 5124;
-	this.UNSIGNED_INT = 5125;
-	this.FLOAT = 5126;
-	this.DEPTH_COMPONENT = 6402;
-	this.ALPHA = 6406;
-	this.RGB = 6407;
-	this.RGBA = 6408;
-	this.LUMINANCE = 6409;
-	this.LUMINANCE_ALPHA = 6410;
-	this.UNSIGNED_SHORT_4_4_4_4 = 32819;
-	this.UNSIGNED_SHORT_5_5_5_1 = 32820;
-	this.UNSIGNED_SHORT_5_6_5 = 33635;
-	this.FRAGMENT_SHADER = 35632;
-	this.VERTEX_SHADER = 35633;
-	this.MAX_VERTEX_ATTRIBS = 34921;
-	this.MAX_VERTEX_UNIFORM_VECTORS = 36347;
-	this.MAX_VARYING_VECTORS = 36348;
-	this.MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661;
-	this.MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660;
-	this.MAX_TEXTURE_IMAGE_UNITS = 34930;
-	this.MAX_FRAGMENT_UNIFORM_VECTORS = 36349;
-	this.SHADER_TYPE = 35663;
-	this.DELETE_STATUS = 35712;
-	this.LINK_STATUS = 35714;
-	this.VALIDATE_STATUS = 35715;
-	this.ATTACHED_SHADERS = 35717;
-	this.ACTIVE_UNIFORMS = 35718;
-	this.ACTIVE_ATTRIBUTES = 35721;
-	this.SHADING_LANGUAGE_VERSION = 35724;
-	this.CURRENT_PROGRAM = 35725;
-	this.NEVER = 512;
-	this.LESS = 513;
-	this.EQUAL = 514;
-	this.LEQUAL = 515;
-	this.GREATER = 516;
-	this.NOTEQUAL = 517;
-	this.GEQUAL = 518;
-	this.ALWAYS = 519;
-	this.KEEP = 7680;
-	this.REPLACE = 7681;
-	this.INCR = 7682;
-	this.DECR = 7683;
-	this.INVERT = 5386;
-	this.INCR_WRAP = 34055;
-	this.DECR_WRAP = 34056;
-	this.VENDOR = 7936;
-	this.RENDERER = 7937;
-	this.VERSION = 7938;
-	this.NEAREST = 9728;
-	this.LINEAR = 9729;
-	this.NEAREST_MIPMAP_NEAREST = 9984;
-	this.LINEAR_MIPMAP_NEAREST = 9985;
-	this.NEAREST_MIPMAP_LINEAR = 9986;
-	this.LINEAR_MIPMAP_LINEAR = 9987;
-	this.TEXTURE_MAG_FILTER = 10240;
-	this.TEXTURE_MIN_FILTER = 10241;
-	this.TEXTURE_WRAP_S = 10242;
-	this.TEXTURE_WRAP_T = 10243;
-	this.TEXTURE = 5890;
-	this.TEXTURE_CUBE_MAP = 34067;
-	this.TEXTURE_BINDING_CUBE_MAP = 34068;
-	this.TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
-	this.TEXTURE_CUBE_MAP_NEGATIVE_X = 34070;
-	this.TEXTURE_CUBE_MAP_POSITIVE_Y = 34071;
-	this.TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072;
-	this.TEXTURE_CUBE_MAP_POSITIVE_Z = 34073;
-	this.TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074;
-	this.MAX_CUBE_MAP_TEXTURE_SIZE = 34076;
-	this.TEXTURE0 = 33984;
-	this.TEXTURE1 = 33985;
-	this.TEXTURE2 = 33986;
-	this.TEXTURE3 = 33987;
-	this.TEXTURE4 = 33988;
-	this.TEXTURE5 = 33989;
-	this.TEXTURE6 = 33990;
-	this.TEXTURE7 = 33991;
-	this.TEXTURE8 = 33992;
-	this.TEXTURE9 = 33993;
-	this.TEXTURE10 = 33994;
-	this.TEXTURE11 = 33995;
-	this.TEXTURE12 = 33996;
-	this.TEXTURE13 = 33997;
-	this.TEXTURE14 = 33998;
-	this.TEXTURE15 = 33999;
-	this.TEXTURE16 = 34000;
-	this.TEXTURE17 = 34001;
-	this.TEXTURE18 = 34002;
-	this.TEXTURE19 = 34003;
-	this.TEXTURE20 = 34004;
-	this.TEXTURE21 = 34005;
-	this.TEXTURE22 = 34006;
-	this.TEXTURE23 = 34007;
-	this.TEXTURE24 = 34008;
-	this.TEXTURE25 = 34009;
-	this.TEXTURE26 = 34010;
-	this.TEXTURE27 = 34011;
-	this.TEXTURE28 = 34012;
-	this.TEXTURE29 = 34013;
-	this.TEXTURE30 = 34014;
-	this.TEXTURE31 = 34015;
-	this.ACTIVE_TEXTURE = 34016;
-	this.REPEAT = 10497;
-	this.CLAMP_TO_EDGE = 33071;
-	this.MIRRORED_REPEAT = 33648;
-	this.FLOAT_VEC2 = 35664;
-	this.FLOAT_VEC3 = 35665;
-	this.FLOAT_VEC4 = 35666;
-	this.INT_VEC2 = 35667;
-	this.INT_VEC3 = 35668;
-	this.INT_VEC4 = 35669;
-	this.BOOL = 35670;
-	this.BOOL_VEC2 = 35671;
-	this.BOOL_VEC3 = 35672;
-	this.BOOL_VEC4 = 35673;
-	this.FLOAT_MAT2 = 35674;
-	this.FLOAT_MAT3 = 35675;
-	this.FLOAT_MAT4 = 35676;
-	this.SAMPLER_2D = 35678;
-	this.SAMPLER_CUBE = 35680;
-	this.VERTEX_ATTRIB_ARRAY_ENABLED = 34338;
-	this.VERTEX_ATTRIB_ARRAY_SIZE = 34339;
-	this.VERTEX_ATTRIB_ARRAY_STRIDE = 34340;
-	this.VERTEX_ATTRIB_ARRAY_TYPE = 34341;
-	this.VERTEX_ATTRIB_ARRAY_NORMALIZED = 34922;
-	this.VERTEX_ATTRIB_ARRAY_POINTER = 34373;
-	this.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 34975;
-	this.IMPLEMENTATION_COLOR_READ_TYPE = 35738;
-	this.IMPLEMENTATION_COLOR_READ_FORMAT = 35739;
-	this.COMPILE_STATUS = 35713;
-	this.LOW_FLOAT = 36336;
-	this.MEDIUM_FLOAT = 36337;
-	this.HIGH_FLOAT = 36338;
-	this.LOW_INT = 36339;
-	this.MEDIUM_INT = 36340;
-	this.HIGH_INT = 36341;
-	this.FRAMEBUFFER = 36160;
-	this.RENDERBUFFER = 36161;
-	this.RGBA4 = 32854;
-	this.RGB5_A1 = 32855;
-	this.RGB565 = 36194;
-	this.DEPTH_COMPONENT16 = 33189;
-	this.STENCIL_INDEX8 = 36168;
-	this.DEPTH_STENCIL = 34041;
-	this.RENDERBUFFER_WIDTH = 36162;
-	this.RENDERBUFFER_HEIGHT = 36163;
-	this.RENDERBUFFER_INTERNAL_FORMAT = 36164;
-	this.RENDERBUFFER_RED_SIZE = 36176;
-	this.RENDERBUFFER_GREEN_SIZE = 36177;
-	this.RENDERBUFFER_BLUE_SIZE = 36178;
-	this.RENDERBUFFER_ALPHA_SIZE = 36179;
-	this.RENDERBUFFER_DEPTH_SIZE = 36180;
-	this.RENDERBUFFER_STENCIL_SIZE = 36181;
-	this.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 36048;
-	this.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 36049;
-	this.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 36050;
-	this.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 36051;
-	this.COLOR_ATTACHMENT0 = 36064;
-	this.DEPTH_ATTACHMENT = 36096;
-	this.STENCIL_ATTACHMENT = 36128;
-	this.DEPTH_STENCIL_ATTACHMENT = 33306;
-	this.NONE = 0;
-	this.FRAMEBUFFER_COMPLETE = 36053;
-	this.FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054;
-	this.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055;
-	this.FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 36057;
-	this.FRAMEBUFFER_UNSUPPORTED = 36061;
-	this.FRAMEBUFFER_BINDING = 36006;
-	this.RENDERBUFFER_BINDING = 36007;
-	this.MAX_RENDERBUFFER_SIZE = 34024;
-	this.INVALID_FRAMEBUFFER_OPERATION = 1286;
-	this.UNPACK_FLIP_Y_WEBGL = 37440;
-	this.UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441;
-	this.CONTEXT_LOST_WEBGL = 37442;
-	this.UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443;
-	this.BROWSER_DEFAULT_WEBGL = 37444;
 
+export default QUnit.module( 'Renderers', () => {
 
-	this.activeTexture = function () {};
+	QUnit.module( 'WebGLRenderer-webonly', () => {
 
-	this.attachShader = function () {};
+		// INSTANCING
+		QUnit.test( 'Instancing', ( assert ) => {
 
-	this.bindAttribLocation = function () {};
+			assert.ok( new WebGLRenderer(), 'Can instantiate a renderer.' );
 
-	this.bindBuffer = function () {};
+		} );
 
-	this.bindFramebuffer = function () {};
+		// PROPERTIES
+		QUnit.todo( 'domElement', ( assert ) => {
 
-	this.bindRenderbuffer = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.bindTexture = function () {};
+		} );
 
-	this.blendColor = function () {};
+		QUnit.todo( 'debug', ( assert ) => {
 
-	this.blendEquation = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.blendEquationSeparate = function () {};
+		} );
 
-	this.blendFunc = function () {};
+		QUnit.todo( 'autoClear', ( assert ) => {
 
-	this.blendFuncSeparate = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.bufferData = function () {};
+		} );
 
-	this.bufferSubData = function () {};
+		QUnit.todo( 'autoClearColor', ( assert ) => {
 
-	this.checkFramebufferStatus = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.clear = function () {};
+		} );
 
-	this.clearColor = function () {};
+		QUnit.todo( 'autoClearDepth', ( assert ) => {
 
-	this.clearDepth = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.clearStencil = function () {};
+		} );
 
-	this.colorMask = function () {};
+		QUnit.todo( 'autoClearStencil', ( assert ) => {
 
-	this.compileShader = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.compressedTexImage2D = function () {};
+		} );
 
-	this.compressedTexSubImage2D = function () {};
+		QUnit.todo( 'sortObjects', ( assert ) => {
 
-	this.copyTexImage2D = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.copyTexSubImage2D = function () {};
+		} );
 
-	this.createBuffer = function () {};
+		QUnit.todo( 'clippingPlanes', ( assert ) => {
 
-	this.createFramebuffer = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.createProgram = function () {};
+		} );
 
-	this.createRenderbuffer = function () {};
+		QUnit.todo( 'localClippingEnabled', ( assert ) => {
 
-	this.createShader = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.createTexture = function () {};
+		} );
 
-	this.cullFace = function () {};
+		QUnit.todo( 'outputEncoding', ( assert ) => {
 
-	this.deleteBuffer = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.deleteFramebuffer = function () {};
+		} );
 
-	this.deleteProgram = function () {};
+		QUnit.todo( 'physicallyCorrectLights', ( assert ) => {
 
-	this.deleteRenderbuffer = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.deleteShader = function () {};
+		} );
 
-	this.deleteTexture = function () {};
+		QUnit.todo( 'toneMapping', ( assert ) => {
 
-	this.depthFunc = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.depthMask = function () {};
+		} );
 
-	this.depthRange = function () {};
+		QUnit.todo( 'toneMappingExposure', ( assert ) => {
 
-	this.detachShader = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.disable = function () {};
+		} );
 
-	this.disableVertexAttribArray = function () {};
+		// PUBLIC
+		QUnit.todo( 'isWebGLRenderer', ( assert ) => {
 
-	this.drawArrays = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.drawElements = function () {};
+		} );
 
-	this.enable = function () {};
+		QUnit.todo( 'getContext', ( assert ) => {
 
-	this.enableVertexAttribArray = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.finish = function () {};
+		} );
 
-	this.flush = function () {};
+		QUnit.todo( 'getContextAttributes', ( assert ) => {
 
-	this.framebufferRenderbuffer = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.framebufferTexture2D = function () {};
+		} );
 
-	this.frontFace = function () {};
+		QUnit.todo( 'forceContextLoss', ( assert ) => {
 
-	this.generateMipmap = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getActiveAttrib = function () {};
+		} );
 
-	this.getActiveUniform = function () {};
+		QUnit.todo( 'forceContextRestore', ( assert ) => {
 
-	this.getAttachedShaders = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getAttribLocation = function () {};
+		} );
 
-	this.getBufferParameter = function () {};
+		QUnit.todo( 'getPixelRatio', ( assert ) => {
 
-	this.getContextAttributes = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getError = function () {};
+		} );
 
-	this.getExtension = function () {};
+		QUnit.todo( 'setPixelRatio', ( assert ) => {
 
-	this.getFramebufferAttachmentParameter = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	var parameters = {};
-	parameters[ this.VERSION ] = 'Custom';
-	this.getParameter = function ( parameterID ) {
+		} );
 
-		return parameters[ parameterID ];
+		QUnit.todo( 'getSize', ( assert ) => {
 
-	};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getProgramParameter = function () {};
+		} );
 
-	this.getProgramInfoLog = function () {};
+		QUnit.todo( 'setSize', ( assert ) => {
 
-	this.getRenderbufferParameter = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getShaderParameter = function () {};
+		} );
 
-	this.getShaderInfoLog = function () {};
+		QUnit.todo( 'getDrawingBufferSize', ( assert ) => {
 
-	this.getShaderPrecisionFormat = function () {
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-		return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };
+		} );
 
-	};
+		QUnit.todo( 'setDrawingBufferSize', ( assert ) => {
 
-	this.getShaderSource = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getSupportedExtensions = function () {};
+		} );
 
-	this.getTexParameter = function () {};
+		QUnit.todo( 'getCurrentViewport', ( assert ) => {
 
-	this.getUniform = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.getUniformLocation = function () {};
+		} );
 
-	this.getVertexAttrib = function () {};
+		QUnit.todo( 'getViewport', ( assert ) => {
 
-	this.getVertexAttribOffset = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.hint = function () {};
+		} );
 
-	this.isBuffer = function () {};
+		QUnit.todo( 'setViewport', ( assert ) => {
 
-	this.isContextLost = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.isEnabled = function () {};
+		} );
 
-	this.isFramebuffer = function () {};
+		QUnit.todo( 'getScissor', ( assert ) => {
 
-	this.isProgram = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.isRenderbuffer = function () {};
+		} );
 
-	this.isShader = function () {};
+		QUnit.todo( 'setScissor', ( assert ) => {
 
-	this.isTexture = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.lineWidth = function () {};
+		} );
 
-	this.linkProgram = function () {};
+		QUnit.todo( 'getScissorTest', ( assert ) => {
 
-	this.pixelStorei = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.polygonOffset = function () {};
+		} );
 
-	this.readPixels = function () {};
+		QUnit.todo( 'setScissorTest', ( assert ) => {
 
-	this.renderbufferStorage = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.sampleCoverage = function () {};
+		} );
 
-	this.scissor = function () {};
+		QUnit.todo( 'setOpaqueSort', ( assert ) => {
 
-	this.shaderSource = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.stencilFunc = function () {};
+		} );
 
-	this.stencilFuncSeparate = function () {};
+		QUnit.todo( 'setTransparentSort', ( assert ) => {
 
-	this.stencilMask = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.stencilMaskSeparate = function () {};
+		} );
 
-	this.stencilOp = function () {};
+		QUnit.todo( 'getClearColor', ( assert ) => {
 
-	this.stencilOpSeparate = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.texParameterf = function () {};
+		} );
 
-	this.texParameteri = function () {};
+		QUnit.todo( 'setClearColor', ( assert ) => {
 
-	this.texImage2D = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.texSubImage2D = function () {};
+		} );
 
-	this.uniform1f = function () {};
+		QUnit.todo( 'getClearAlpha', ( assert ) => {
 
-	this.uniform1fv = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.uniform1i = function () {};
+		} );
 
-	this.uniform1iv = function () {};
+		QUnit.todo( 'setClearAlpha', ( assert ) => {
 
-	this.uniform2f = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.uniform2fv = function () {};
+		} );
 
-	this.uniform2i = function () {};
+		QUnit.todo( 'clear', ( assert ) => {
 
-	this.uniform2iv = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.uniform3f = function () {};
+		} );
 
-	this.uniform3fv = function () {};
+		QUnit.todo( 'clearColor', ( assert ) => {
 
-	this.uniform3i = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.uniform3iv = function () {};
+		} );
 
-	this.uniform4f = function () {};
+		QUnit.todo( 'clearDepth', ( assert ) => {
 
-	this.uniform4fv = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.uniform4i = function () {};
+		} );
 
-	this.uniform4iv = function () {};
+		QUnit.todo( 'clearStencil', ( assert ) => {
 
-	this.uniformMatrix2fv = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.uniformMatrix3fv = function () {};
+		} );
 
-	this.uniformMatrix4fv = function () {};
+		QUnit.todo( 'dispose', ( assert ) => {
 
-	this.useProgram = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.validateProgram = function () {};
+		} );
 
-	this.vertexAttrib1f = function () {};
+		QUnit.todo( 'renderBufferDirect', ( assert ) => {
 
-	this.vertexAttrib1fv = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.vertexAttrib2f = function () {};
+		} );
 
-	this.vertexAttrib2fv = function () {};
+		QUnit.todo( 'compile', ( assert ) => {
 
-	this.vertexAttrib3f = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.vertexAttrib3fv = function () {};
+		} );
 
-	this.vertexAttrib4f = function () {};
+		QUnit.todo( 'setAnimationLoop', ( assert ) => {
 
-	this.vertexAttrib4fv = function () {};
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-	this.vertexAttribPointer = function () {};
+		} );
 
-	this.viewport = function () {};
+		QUnit.todo( 'render', ( assert ) => {
 
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-};
-*/
-export default QUnit.module( 'Renderers', () => {
+		} );
 
-	QUnit.module( 'WebGLRenderer-webonly', () => {
+		QUnit.todo( 'getActiveCubeFace', ( assert ) => {
 
-		QUnit.test( 'Instancing', ( assert ) => {
+			assert.ok( false, 'everything\'s gonna be alright' );
 
-			assert.ok( new WebGLRenderer(), 'Can instantiate a renderer.' );
+		} );
+
+		QUnit.todo( 'getActiveMipmapLevel', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'getRenderTarget', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'getRenderTarget', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setRenderTargetTextures', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setRenderTargetFramebuffer', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'setRenderTarget', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'readRenderTargetPixels', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'copyFramebufferToTexture', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'copyTextureToTexture', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'copyTextureToTexture3D', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'initTexture', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'resetState', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
 
 		} );
 

test/unit/src/renderers/shaders/ShaderChunk.tests.js

@@ -1,6 +1,6 @@
 /* global QUnit */
 
-// import { ShaderChunk } from '../../../../../src/renderers/shaders/ShaderChunk.js';
+import { ShaderChunk } from '../../../../../src/renderers/shaders/ShaderChunk.js';
 
 export default QUnit.module( 'Renderers', () => {
 
@@ -8,9 +8,10 @@ export default QUnit.module( 'Renderers', () => {
 
 		QUnit.module( 'ShaderChunk', () => {
 
-			QUnit.todo( 'write me !', ( assert ) => {
+			// INSTANCING
+			QUnit.test( 'Instancing', ( assert ) => {
 
-				assert.ok( false, 'everything\'s gonna be alright' );
+				assert.ok( ShaderChunk, 'ShaderChunk is defined.' );
 
 			} );
 

test/unit/src/renderers/shaders/ShaderLib.tests.js

@@ -1,6 +1,6 @@
 /* global QUnit */
 
-// import { ShaderLib } from '../../../../../src/renderers/shaders/ShaderLib.js';
+import { ShaderLib } from '../../../../../src/renderers/shaders/ShaderLib.js';
 
 export default QUnit.module( 'Renderers', () => {
 
@@ -8,9 +8,10 @@ export default QUnit.module( 'Renderers', () => {
 
 		QUnit.module( 'ShaderLib', () => {
 
-			QUnit.todo( 'write me !', ( assert ) => {
+			// INSTANCING
+			QUnit.test( 'Instancing', ( assert ) => {
 
-				assert.ok( false, 'everything\'s gonna be alright' );
+				assert.ok( ShaderLib, 'ShaderLib is defined.' );
 
 			} );
 

test/unit/src/renderers/shaders/UniformsLib.tests.js

@@ -1,6 +1,6 @@
 /* global QUnit */
 
-// import { UniformsLib } from '../../../../../src/renderers/shaders/UniformsLib.js';
+import { UniformsLib } from '../../../../../src/renderers/shaders/UniformsLib.js';
 
 export default QUnit.module( 'Renderers', () => {
 
@@ -8,16 +8,10 @@ export default QUnit.module( 'Renderers', () => {
 
 		QUnit.module( 'UniformsLib', () => {
 
-			// PUBLIC STUFF
-			QUnit.todo( 'merge', ( assert ) => {
+			// INSTANCING
+			QUnit.test( 'Instancing', ( assert ) => {
 
-				assert.ok( false, 'everything\'s gonna be alright' );
-
-			} );
-
-			QUnit.todo( 'clone', ( assert ) => {
-
-				assert.ok( false, 'everything\'s gonna be alright' );
+				assert.ok( UniformsLib, 'UniformsLib is defined.' );
 
 			} );
 

test/unit/src/renderers/shaders/UniformsUtils.tests.js

@@ -1,6 +1,6 @@
 /* global QUnit */
 
-// import { UniformsUtils } from '../../../../../src/renderers/shaders/UniformsUtils.js';
+import { UniformsUtils } from '../../../../../src/renderers/shaders/UniformsUtils.js';
 
 export default QUnit.module( 'Renderers', () => {
 
@@ -8,7 +8,46 @@ export default QUnit.module( 'Renderers', () => {
 
 		QUnit.module( 'UniformsUtils', () => {
 
-			QUnit.todo( 'write me !', ( assert ) => {
+			// INSTANCING - LEGACY
+			QUnit.test( 'Instancing', ( assert ) => {
+
+				assert.ok( UniformsUtils, 'UniformsUtils is defined.' );
+
+			} );
+
+			// LEGACY
+			QUnit.todo( 'UniformsUtils.clone', ( assert ) => {
+
+				assert.ok( false, 'everything\'s gonna be alright' );
+
+			} );
+
+			QUnit.todo( 'UniformsUtils.merge', ( assert ) => {
+
+				assert.ok( false, 'everything\'s gonna be alright' );
+
+			} );
+
+			// PUBLIC
+			QUnit.todo( 'cloneUniforms', ( assert ) => {
+
+				assert.ok( false, 'everything\'s gonna be alright' );
+
+			} );
+
+			QUnit.todo( 'mergeUniforms', ( assert ) => {
+
+				assert.ok( false, 'everything\'s gonna be alright' );
+
+			} );
+
+			QUnit.todo( 'cloneUniformsGroups', ( assert ) => {
+
+				assert.ok( false, 'everything\'s gonna be alright' );
+
+			} );
+
+			QUnit.todo( 'getUnlitUniformColorSpace', ( assert ) => {
 
 				assert.ok( false, 'everything\'s gonna be alright' );
 

test/unit/three.source.unit.js

@@ -217,9 +217,13 @@ import './src/objects/Sprite.tests.js';
 
 
 //src/renderers
+import './src/renderers/WebGL1Renderer.tests.js';
+import './src/renderers/WebGL3DRenderTarget.tests.js';
+import './src/renderers/WebGLArrayRenderTarget.tests.js';
+import './src/renderers/WebGLCubeRenderTarget.tests.js';
+import './src/renderers/WebGLMultipleRenderTargets.tests.js';
 import './src/renderers/WebGLRenderer.tests.js';
 import './src/renderers/WebGLRenderTarget.tests.js';
-import './src/renderers/WebGLCubeRenderTarget.tests.js';
 
 //src/renderers/shaders
 import './src/renderers/shaders/ShaderChunk.tests.js';