Merge pull request #12217 from moraxy/unit_tests_fix

Fix and update unit tests

test/Three.Unit.js

@@ -35,6 +35,7 @@ export { PositionalAudio } from '../src/audio/PositionalAudio.js';
 
 
 //src/cameras
+export { ArrayCamera } from '../src/cameras/ArrayCamera.js';
 export { Camera } from '../src/cameras/Camera.js';
 export { CubeCamera } from '../src/cameras/CubeCamera.js';
 export { OrthographicCamera } from '../src/cameras/OrthographicCamera.js';
@@ -99,11 +100,13 @@ export * from '../src/geometries/Geometries.js';
 export { ArrowHelper } from '../src/helpers/ArrowHelper.js';
 export { AxisHelper } from '../src/helpers/AxisHelper.js';
 export { BoxHelper } from '../src/helpers/BoxHelper.js';
+export { Box3Helper } from '../src/helpers/Box3Helper.js';
 export { CameraHelper } from '../src/helpers/CameraHelper.js';
 export { DirectionalLightHelper } from '../src/helpers/DirectionalLightHelper.js';
 export { FaceNormalsHelper } from '../src/helpers/FaceNormalsHelper.js';
 export { GridHelper } from '../src/helpers/GridHelper.js';
 export { HemisphereLightHelper } from '../src/helpers/HemisphereLightHelper.js';
+export { PlaneHelper } from '../src/helpers/PlaneHelper.js';
 export { PointLightHelper } from '../src/helpers/PointLightHelper.js';
 export { PolarGridHelper } from '../src/helpers/PolarGridHelper.js';
 export { RectAreaLightHelper } from '../src/helpers/RectAreaLightHelper.js';
@@ -121,7 +124,6 @@ export { Light } from '../src/lights/Light.js';
 export { LightShadow } from '../src/lights/LightShadow.js';
 export { PointLight } from '../src/lights/PointLight.js';
 export { RectAreaLight } from '../src/lights/RectAreaLight.js';
-//export { RectAreaLightShadow } from '../src/lights/RectAreaLightShadow.js'; //Todo (tristan): Need to be fixed !
 export { SpotLight } from '../src/lights/SpotLight.js';
 export { SpotLightShadow } from '../src/lights/SpotLightShadow.js';
 
@@ -183,6 +185,7 @@ export { Bone } from '../src/objects/Bone.js';
 export { Group } from '../src/objects/Group.js';
 export { LensFlare } from '../src/objects/LensFlare.js';
 export { Line } from '../src/objects/Line.js';
+export { LineLoop } from '../src/objects/LineLoop.js';
 export { LineSegments } from '../src/objects/LineSegments.js';
 export { LOD } from '../src/objects/LOD.js';
 export { Mesh } from '../src/objects/Mesh.js';
@@ -205,25 +208,32 @@ export { UniformsLib } from '../src/renderers/shaders/UniformsLib.js';
 export { UniformsUtils } from '../src/renderers/shaders/UniformsUtils.js';
 
 //src/renderers/webgl
+export { WebGLAttributes } from '../src/renderers/webgl/WebGLAttributes.js';
+export { WebGLBackground } from '../src/renderers/webgl/WebGLBackground.js';
 export { WebGLBufferRenderer } from '../src/renderers/webgl/WebGLBufferRenderer.js';
 export { WebGLCapabilities } from '../src/renderers/webgl/WebGLCapabilities.js';
 export { WebGLClipping } from '../src/renderers/webgl/WebGLClipping.js';
 export { WebGLExtensions } from '../src/renderers/webgl/WebGLExtensions.js';
+export { WebGLFlareRenderer } from '../src/renderers/webgl/WebGLFlareRenderer.js';
 export { WebGLGeometries } from '../src/renderers/webgl/WebGLGeometries.js';
 export { WebGLIndexedBufferRenderer } from '../src/renderers/webgl/WebGLIndexedBufferRenderer.js';
 export { WebGLLights } from '../src/renderers/webgl/WebGLLights.js';
+export { WebGLMorphtargets } from '../src/renderers/webgl/WebGLMorphtargets.js';
 export { WebGLObjects } from '../src/renderers/webgl/WebGLObjects.js';
 export { WebGLProgram } from '../src/renderers/webgl/WebGLProgram.js';
+export { WebGLPrograms } from '../src/renderers/webgl/WebGLPrograms.js';
 export { WebGLProperties } from '../src/renderers/webgl/WebGLProperties.js';
+export { WebGLRenderLists } from '../src/renderers/webgl/WebGLRenderLists.js';
 export { WebGLShader } from '../src/renderers/webgl/WebGLShader.js';
 export { WebGLShadowMap } from '../src/renderers/webgl/WebGLShadowMap.js';
+export { WebGLSpriteRenderer } from '../src/renderers/webgl/WebGLSpriteRenderer.js';
 export { WebGLState } from '../src/renderers/webgl/WebGLState.js';
 export { WebGLTextures } from '../src/renderers/webgl/WebGLTextures.js';
 export { WebGLUniforms } from '../src/renderers/webgl/WebGLUniforms.js';
+export { WebGLUtils } from '../src/renderers/webgl/WebGLUtils.js';
 
-//src/renderers/webgl/plugins
-export { LensFlarePlugin } from '../src/renderers/webgl/plugins/LensFlarePlugin.js';
-export { SpritePlugin } from '../src/renderers/webgl/plugins/SpritePlugin.js';
+//src/renderers/webvr
+export { WebVRManager } from '../src/renderers/webvr/WebVRManager.js';
 
 
 //src/scenes

test/unit/qunit-utils.js

@@ -5,14 +5,24 @@
 QUnit.assert.success = function( message ) {
 
 	// Equivalent to assert( true, message );
-	QUnit.assert.push( true, undefined, undefined, message );
+	this.pushResult( {
+		result: true,
+		actual: undefined,
+		expected: undefined,
+		message: message
+	} );
 
 };
 
 QUnit.assert.fail = function( message ) {
 
 	// Equivalent to assert( false, message );
-	QUnit.assert.push( false, undefined, undefined, message );
+	this.pushResult( {
+		result: false,
+		actual: undefined,
+		expected: undefined,
+		message: message
+	} );
 
 };
 
@@ -20,7 +30,12 @@ QUnit.assert.numEqual = function( actual, expected, message ) {
 
 	var diff = Math.abs(actual - expected);
 	message = message || ( actual + " should be equal to " + expected );
-	QUnit.assert.push( diff < 0.1, actual, expected, message );
+	this.pushResult( {
+		result: diff < 0.1,
+		actual: actual,
+		expected: expected,
+		message: message
+	} );
 
 };
 
@@ -29,7 +44,12 @@ QUnit.assert.equalKey = function( obj, ref, key ) {
 	var actual = obj[key];
 	var expected = ref[key];
 	var message = actual + ' should be equal to ' + expected + ' for key "' + key + '"';
-	QUnit.assert.push( actual == expected, actual, expected, message );
+	this.pushResult( {
+		result: actual == expected,
+		actual: actual,
+		expected: expected,
+		message: message
+	} );
 
 };
 
@@ -40,7 +60,12 @@ QUnit.assert.smartEqual = function( actual, expected, message ) {
 	var same = cmp.areEqual(actual, expected);
 	var msg = cmp.getDiagnostic() || message;
 
-	QUnit.assert.push( same, actual, expected, msg );
+	this.pushResult( {
+		result: same,
+		actual: actual,
+		expected: expected,
+		message: msg
+	} );
 
 };
 
@@ -76,7 +101,6 @@ function getDifferingProp( geometryA, geometryB, excludedProperties) {
 	var geometryKeys = Object.keys( geometryA );
 	var cloneKeys = Object.keys( geometryB );
 
-	var keysWhichAreNotChecked = [ 'parameters', 'widthSegments', 'heightSegments', 'depthSegments' ];
 	var differingProp = undefined;
 
 	for ( var i = 0, l = geometryKeys.length; i < l; i++ ) {
@@ -100,7 +124,7 @@ function getDifferingProp( geometryA, geometryB, excludedProperties) {
 // Compare json file with its source geometry.
 function checkGeometryJsonWriting( geom, json ) {
 
-	QUnit.assert.equal( json.metadata.version, "4.4", "check metadata version" );
+	QUnit.assert.equal( json.metadata.version, "4.5", "check metadata version" );
 	QUnit.assert.equalKey( geom, json, 'type' );
 	QUnit.assert.equalKey( geom, json, 'uuid' );
 	QUnit.assert.equal( json.id, undefined, "should not persist id" );
@@ -252,7 +276,7 @@ function checkLightClone( light ) {
 // Compare json file with its source Light.
 function checkLightJsonWriting( light, json ) {
 
-	QUnit.assert.equal( json.metadata.version, "4.4", "check metadata version" );
+	QUnit.assert.equal( json.metadata.version, "4.5", "check metadata version" );
 
 	var object = json.object;
 	QUnit.assert.equalKey( light, object, 'type' );

test/unit/src/cameras/PerspectiveCamera.js

@@ -4,7 +4,31 @@
 
 QUnit.module( "PerspectiveCamera" );
 
-QUnit.test( "updateProjectionMatrix" , function( assert ) {
+// see e.g. math/Matrix4.js
+var matrixEquals4 = function ( a, b, tolerance ) {
+
+	tolerance = tolerance || 0.0001;
+	if ( a.elements.length != b.elements.length ) {
+
+		return false;
+
+	}
+	for ( var i = 0, il = a.elements.length; i < il; i ++ ) {
+
+		var delta = a.elements[ i ] - b.elements[ i ];
+		if ( delta > tolerance ) {
+
+			return false;
+
+		}
+
+	}
+
+	return true;
+
+};
+
+QUnit.test( "updateProjectionMatrix", function ( assert ) {
 
 	var cam = new THREE.PerspectiveCamera( 75, 16 / 9, 0.1, 300.0 );
 
@@ -22,12 +46,14 @@ QUnit.test( "updateProjectionMatrix" , function( assert ) {
 	var reference = new THREE.Matrix4().set(
 		0.7330642938613892, 0, 0, 0,
 		0, 1.3032253980636597, 0, 0,
-		0, 0, -1.000666856765747, -0.2000666856765747,
-		0, 0, -1, 0
+		0, 0, - 1.000666856765747, - 0.2000666856765747,
+		0, 0, - 1, 0
 	);
 
-	assert.ok( reference.equals(m) );
-});
+	// assert.ok( reference.equals(m) );
+	assert.ok( matrixEquals4( reference, m, 0.000001 ) );
+
+} );
 
 QUnit.test( "clone" , function( assert ) {
 	var near = 1,

test/unit/src/core/InstancedBufferGeometry.js

@@ -31,7 +31,7 @@ QUnit.test( "copy" , function( assert ) {
 	instance.addAttribute( 'defaultAttribute1', defaultAttribute1 );
 	instance.addAttribute( 'defaultAttribute2', defaultAttribute2 );
 
-	var copiedInstance = instance.copy( instance );
+	var copiedInstance = new THREE.InstancedBufferGeometry().copy( instance );
 
 	assert.ok( copiedInstance instanceof THREE.InstancedBufferGeometry, "the clone has the correct type" );
 

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

@@ -27,8 +27,8 @@ QUnit.test( "catmullrom check", function( assert ) {
 		new THREE.Vector3( - 60, 120, 60 ),
 		new THREE.Vector3( - 14.880000000000017, 95.36000000000001, 14.880000000000017 ),
 		new THREE.Vector3( 41.75999999999997, 44.48000000000003, - 41.75999999999997 ),
-		new THREE.Vector3( 67.68, - 4.640000000000025, - 67.68 ),
-		new THREE.Vector3( 65.75999999999999, - 59.68000000000002, - 65.75999999999999 ),
+		new THREE.Vector3( 67.68, - 2.720000000000023, - 67.68 ),
+		new THREE.Vector3( 65.75999999999999, - 51.04000000000001, - 65.75999999999999 ),
 		new THREE.Vector3( 60, - 100, - 60 )
 
 	];
@@ -62,8 +62,8 @@ QUnit.test( "chordal basic check", function( assert ) {
 		new THREE.Vector3( - 60, 120, 60 ),
 		new THREE.Vector3( - 16.302568199486444, 114.1500463116312, 16.302568199486444 ),
 		new THREE.Vector3( 42.998098664956586, 54.017050116427455, - 42.998098664956586 ),
-		new THREE.Vector3( 63.542500175682434, - 3.0571533975463856, - 63.542500175682434 ),
-		new THREE.Vector3( 62.65687513176183, - 58.49286504815978, - 62.65687513176183 ),
+		new THREE.Vector3( 63.542500175682434, - 1.137153397546383, - 63.542500175682434 ),
+		new THREE.Vector3( 62.65687513176183, - 49.85286504815978, - 62.65687513176183 ),
 		new THREE.Vector3( 60.00000000000001, - 100, - 60.00000000000001 )
 	];
 
@@ -95,8 +95,8 @@ QUnit.test( "centripetal basic check", function( assert ) {
 		new THREE.Vector3( - 60, 120, 60 ),
 		new THREE.Vector3( - 15.620412575504497, 103.10790870179872, 15.620412575504497 ),
 		new THREE.Vector3( 42.384384731047874, 48.35477686933143, - 42.384384731047874 ),
-		new THREE.Vector3( 65.25545512241153, - 3.5662509660683424, - 65.25545512241153 ),
-		new THREE.Vector3( 63.94159134180865, - 58.87468822455125, - 63.94159134180865 ),
+		new THREE.Vector3( 65.25545512241153, - 1.646250966068339, - 65.25545512241153 ),
+		new THREE.Vector3( 63.94159134180865, - 50.234688224551256, - 63.94159134180865 ),
 		new THREE.Vector3( 59.99999999999999, - 100, - 59.99999999999999 ),
 	];
 

test/unit/src/math/Plane.js

@@ -165,13 +165,6 @@ QUnit.test( "projectPoint" , function( assert ) {
 
 });
 
-QUnit.test( "orthoPoint" , function( assert ) {
-	var a = new THREE.Plane( new THREE.Vector3( 1, 0, 0 ), 0 );
-
-	assert.ok( a.orthoPoint( new THREE.Vector3( 10, 0, 0 ) ).equals( new THREE.Vector3( 10, 0, 0 ) ), "Passed!" );
-	assert.ok( a.orthoPoint( new THREE.Vector3( -10, 0, 0 ) ).equals( new THREE.Vector3( -10, 0, 0 ) ), "Passed!" );
-});
-
 QUnit.test( "coplanarPoint" , function( assert ) {
 	var a = new THREE.Plane( new THREE.Vector3( 1, 0, 0 ), 0 );
 	assert.ok( a.distanceToPoint( a.coplanarPoint() ) === 0, "Passed!" );

test/unit/src/math/Triangle.js

@@ -96,10 +96,10 @@ QUnit.test( "normal" , function( assert ) {
 QUnit.test( "plane" , function( assert ) {
 	var a = new THREE.Triangle();
 
-	assert.ok( isNaN( a.plane().distanceToPoint( a.a ) ), "Passed!" );
-	assert.ok( isNaN( a.plane().distanceToPoint( a.b ) ), "Passed!" );
-	assert.ok( isNaN( a.plane().distanceToPoint( a.c ) ), "Passed!" );
-	assert.propEqual( a.plane().normal, {x: NaN, y: NaN, z: NaN}, "Passed!" );
+	assert.notOk( isNaN( a.plane().distanceToPoint( a.a ) ), "Passed!" );
+	assert.notOk( isNaN( a.plane().distanceToPoint( a.b ) ), "Passed!" );
+	assert.notOk( isNaN( a.plane().distanceToPoint( a.c ) ), "Passed!" );
+	assert.notPropEqual( a.plane().normal, { x: NaN, y: NaN, z: NaN }, "Passed!" );
 
 	a = new THREE.Triangle( new THREE.Vector3( 0, 0, 0 ), new THREE.Vector3( 1, 0, 0 ), new THREE.Vector3( 0, 1, 0 ) );
 	assert.ok( a.plane().distanceToPoint( a.a ) == 0, "Passed!" );

test/unit/src/math/Vector2.js

@@ -225,6 +225,8 @@ QUnit.test( "setLength" , function( assert ) {
 	a = new THREE.Vector2( 0, 0 );
 	assert.ok( a.length() == 0, "Passed!" );
 	a.setLength( y );
+	assert.ok( a.length() == 0, "Passed!" );
+	a.setLength();
 	assert.ok( isNaN( a.length() ), "Passed!" );
 });
 

test/unit/src/math/Vector3.js

@@ -235,6 +235,8 @@ QUnit.test( "setLength" , function( assert ) {
 	a = new THREE.Vector3( 0, 0, 0 );
 	assert.ok( a.length() == 0, "Passed!" );
 	a.setLength( y );
+	assert.ok( a.length() == 0, "Passed!" );
+	a.setLength();
 	assert.ok( isNaN( a.length() ), "Passed!" );
 
 });

test/unit/src/math/Vector4.js

@@ -275,6 +275,8 @@ QUnit.test( "setLength" , function( assert ) {
 	a = new THREE.Vector4( 0, 0, 0, 0 );
 	assert.ok( a.length() == 0, "Passed!" );
 	a.setLength( y );
+	assert.ok( a.length() == 0, "Passed!" );
+	a.setLength();
 	assert.ok( isNaN( a.length() ), "Passed!" );
 });