Merge pull request #13555 from Mugen87/dev4

Tests: Fixed some unit tests

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

@@ -11,12 +11,12 @@ import { Object3D } from '../../../../src/core/Object3D';
 import { LoopOnce, LoopRepeat, LoopPingPong } from '../../../../src/constants';
 
 
-function createAnimation(){
+function createAnimation() {
 
 	var root = new Object3D();
-	var mixer = new AnimationMixer(root);
+	var mixer = new AnimationMixer( root );
 	var track = new NumberKeyframeTrack( ".rotation[x]", [ 0, 1000 ], [ 0, 360 ] );
-	var clip = new AnimationClip( "clip1", 1000, [track] );
+	var clip = new AnimationClip( "clip1", 1000, [ track ] );
 
 	var animationAction = mixer.clipAction( clip );
 	return {
@@ -29,16 +29,16 @@ function createAnimation(){
 
 }
 
-function createTwoAnimations(){
+function createTwoAnimations() {
 
 	var root = new Object3D();
-	var mixer = new AnimationMixer(root);
+	var mixer = new AnimationMixer( root );
 	var track = new NumberKeyframeTrack( ".rotation[x]", [ 0, 1000 ], [ 0, 360 ] );
-	var clip = new AnimationClip( "clip1", 1000, [track] );
+	var clip = new AnimationClip( "clip1", 1000, [ track ] );
 	var animationAction = mixer.clipAction( clip );
 
 	var track2 = new NumberKeyframeTrack( ".rotation[y]", [ 0, 1000 ], [ 0, 360 ] );
-	var clip2 = new AnimationClip( "clip2", 1000, [track] );
+	var clip2 = new AnimationClip( "clip2", 1000, [ track ] );
 	var animationAction2 = mixer.clipAction( clip2 );
 
 	return {
@@ -73,7 +73,7 @@ export default QUnit.module( 'Animation', () => {
 		// PUBLIC STUFF
 		QUnit.test( "play", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
+			var { mixer, animationAction } = createAnimation();
 			var animationAction2 = animationAction.play();
 			assert.equal( animationAction, animationAction2, "AnimationAction.play can be chained." );
 
@@ -101,7 +101,7 @@ export default QUnit.module( 'Animation', () => {
 
 		QUnit.test( "stop", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
+			var { mixer, animationAction } = createAnimation();
 			var animationAction2 = animationAction.stop();
 			assert.equal( animationAction, animationAction2, "AnimationAction.stop can be chained." );
 
@@ -129,7 +129,7 @@ export default QUnit.module( 'Animation', () => {
 
 		QUnit.test( "reset", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
+			var { mixer, animationAction } = createAnimation();
 			var animationAction2 = animationAction.stop();
 			assert.equal( animationAction, animationAction2, "AnimationAction.reset can be chained." );
 			assert.equal( animationAction2.paused, false, "AnimationAction.reset() sets paused false" );
@@ -142,7 +142,7 @@ export default QUnit.module( 'Animation', () => {
 
 		QUnit.test( "isRunning", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
+			var { mixer, animationAction } = createAnimation();
 			assert.notOk( animationAction.isRunning(), "When an animation is just made, it is not running." );
 			animationAction.play();
 			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
@@ -161,196 +161,188 @@ export default QUnit.module( 'Animation', () => {
 
 		QUnit.test( "isScheduled", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
+			var { mixer, animationAction } = createAnimation();
 			assert.notOk( animationAction.isScheduled(), "When an animation is just made, it is not scheduled." );
 			animationAction.play();
 			assert.ok( animationAction.isScheduled(), "When an animation is started, it is scheduled." );
-			mixer.update(1);
+			mixer.update( 1 );
 			assert.ok( animationAction.isScheduled(), "When an animation is updated, it is scheduled." );
 			animationAction.stop();
 			assert.notOk( animationAction.isScheduled(), "When an animation is stopped, it isn't scheduled anymore." );
 
-		   
+
 		} );
 
 		QUnit.test( "startAt", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
-			animationAction.startAt(2);
+			var { mixer, animationAction } = createAnimation();
+			animationAction.startAt( 2 );
 			animationAction.play();
 			assert.notOk( animationAction.isRunning(), "When an animation is started at a specific time, it is not running." );
 			assert.ok( animationAction.isScheduled(), "When an animation is started at a specific time, it is scheduled." );
-			mixer.update(1);
+			mixer.update( 1 );
 			assert.notOk( animationAction.isRunning(), "When an animation is started at a specific time and the interval is not passed, it is not running." );
 			assert.ok( animationAction.isScheduled(), "When an animation is started at a specific time and the interval is not passed, it is scheduled." );
-			mixer.update(1);
+			mixer.update( 1 );
 			assert.ok( animationAction.isRunning(), "When an animation is started at a specific time and the interval is passed, it is running." );
 			assert.ok( animationAction.isScheduled(), "When an animation is started at a specific time and the interval is passed, it is scheduled." );
 			animationAction.stop();
 			assert.notOk( animationAction.isRunning(), "When an animation is stopped, it is not running." );
 			assert.notOk( animationAction.isScheduled(), "When an animation is stopped, it is not scheduled." );
-			
+
 
 		} );
 
 		QUnit.test( "setLoop LoopOnce", ( assert ) => {
 
-			var {mixer,animationAction} = createAnimation();
-			animationAction.setLoop(LoopOnce);
+			var { mixer, animationAction } = createAnimation();
+			animationAction.setLoop( LoopOnce );
 			animationAction.play();
 			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.ok( animationAction.isRunning(), "When an animation is in the first loop, it is running." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.notOk( animationAction.isRunning(), "When an animation is ended, it is not running." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.notOk( animationAction.isRunning(), "When an animation is ended, it is not running." );
-	
+
 		} );
-	
+
 		QUnit.test( "setLoop LoopRepeat", ( assert ) => {
-	
-			var { root, mixer,animationAction } = createAnimation();
-			animationAction.setLoop(LoopRepeat,3);
+
+			var { root, mixer, animationAction } = createAnimation();
+			animationAction.setLoop( LoopRepeat, 3 );
 			animationAction.play();
 			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
-			mixer.update(750);
-			assert.equal( root.rotation.x, 270 , "When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopRepeat." );
+			mixer.update( 750 );
+			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopRepeat." );
 			assert.ok( animationAction.isRunning(), "When an animation is in the first loop, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 270 , "When an animation is 3/4 in the second loop, it has changed to 3/4 when LoopRepeat." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the second loop, it has changed to 3/4 when LoopRepeat." );
 			assert.ok( animationAction.isRunning(), "When an animation is in second loop when in looprepeat 3 times, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 270 , "When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopRepeat." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopRepeat." );
 			assert.ok( animationAction.isRunning(), "When an animation is in third loop when in looprepeat 3 times, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 270 , "When an animation is 3/4 in the fourth loop, it has changed to 3/4 when LoopRepeat." );
-			assert.ok( animationAction.isRunning(), "When an animation is in fourth loop when in looprepeat 3 times, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 0 , "When an animation ended his third loop when in looprepeat 3 times, it stays on the end result." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 0, "When an animation ended his third loop when in looprepeat 3 times, it stays on the end result." );
 			assert.notOk( animationAction.isRunning(), "When an animation ended his third loop when in looprepeat 3 times, it stays not running anymore." );
-			
+
 		} );
 
 		QUnit.test( "setLoop LoopPingPong", ( assert ) => {
-	
-			var {root, mixer,animationAction} = createAnimation();
-			animationAction.setLoop(LoopPingPong,3);
+
+			var { root, mixer, animationAction } = createAnimation();
+			animationAction.setLoop( LoopPingPong, 3 );
 			animationAction.play();
 			assert.ok( animationAction.isRunning(), "When an animation is started, it is running." );
-			mixer.update(750);
-			assert.equal( root.rotation.x, 270 , "When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopPingPong." );
+			mixer.update( 750 );
+			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the first loop, it has changed to 3/4 when LoopPingPong." );
 			assert.ok( animationAction.isRunning(), "When an animation is in the first loop, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 90 ,  "When an animation is 3/4 in the second loop, it has changed to 1/4 when LoopPingPong." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 90, "When an animation is 3/4 in the second loop, it has changed to 1/4 when LoopPingPong." );
 			assert.ok( animationAction.isRunning(), "When an animation is in second loop when in looprepeat 3 times, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 270 ,  "When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopPingPong." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 270, "When an animation is 3/4 in the third loop, it has changed to 3/4 when LoopPingPong." );
 			assert.ok( animationAction.isRunning(), "When an animation is in third loop when in looprepeat 3 times, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 90 ,  "When an animation is 3/4 in the fourth loop, it has changed to 1/4 when LoopPingPong." );
-			assert.ok( animationAction.isRunning(), "When an animation is in fourth loop when in looprepeat 3 times, it is running." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 0 , "When an animation ended his fourth loop when in looprepeat 3 times, it stays on the end result." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 0, "When an animation ended his fourth loop when in looprepeat 3 times, it stays on the end result." );
 			assert.notOk( animationAction.isRunning(), "When an animation ended his fourth loop when in looprepeat 3 times, it stays not running anymore." );
-			
+
 		} );
 
 		QUnit.test( "setEffectiveWeight", ( assert ) => {
 
-			var {animationAction} = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation is created, EffectiveWeight is 1." );
-			animationAction.setEffectiveWeight(0.3);
-			assert.equal( animationAction.getEffectiveWeight(), 0.3 , "When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3." );
+			var { animationAction } = createAnimation();
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
+			animationAction.setEffectiveWeight( 0.3 );
+			assert.equal( animationAction.getEffectiveWeight(), 0.3, "When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3." );
 
 
-			var {animationAction} = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation is created, EffectiveWeight is 1." );
+			var { animationAction } = createAnimation();
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
 			animationAction.enabled = false;
-			animationAction.setEffectiveWeight(0.3);
-			assert.equal( animationAction.getEffectiveWeight(), 0 , "When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0." );
+			animationAction.setEffectiveWeight( 0.3 );
+			assert.equal( animationAction.getEffectiveWeight(), 0, "When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0." );
 
 
-			var { root, mixer,animationAction } = createAnimation();
-			animationAction.setEffectiveWeight(0.5);
+			var { root, mixer, animationAction } = createAnimation();
+			animationAction.setEffectiveWeight( 0.5 );
 			animationAction.play();
-			mixer.update(500);
-			assert.equal( root.rotation.x, 90 ,  "When an animation has weight 0.5 and runs half through the animation, it has changed to 1/4." );
-			mixer.update(1000);
-			assert.equal( root.rotation.x, 90 ,  "When an animation has weight 0.5 and runs one and half through the animation, it has changed to 1/4." );
-
-
+			mixer.update( 500 );
+			assert.equal( root.rotation.x, 90, "When an animation has weight 0.5 and runs half through the animation, it has changed to 1/4." );
+			mixer.update( 1000 );
+			assert.equal( root.rotation.x, 90, "When an animation has weight 0.5 and runs one and half through the animation, it has changed to 1/4." );
 
 		} );
 
 		QUnit.test( "getEffectiveWeight", ( assert ) => {
 
-			var {animationAction} = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation is created, EffectiveWeight is 1." );
-			animationAction.setEffectiveWeight(0.3);
-			assert.equal( animationAction.getEffectiveWeight(), 0.3 , "When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3." );
+			var { animationAction } = createAnimation();
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
+			animationAction.setEffectiveWeight( 0.3 );
+			assert.equal( animationAction.getEffectiveWeight(), 0.3, "When EffectiveWeight is set to 0.3 , EffectiveWeight is 0.3." );
 
 
-			var {animationAction} = createAnimation();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation is created, EffectiveWeight is 1." );
+			var { animationAction } = createAnimation();
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation is created, EffectiveWeight is 1." );
 			animationAction.enabled = false;
-			animationAction.setEffectiveWeight(0.3);
-			assert.equal( animationAction.getEffectiveWeight(), 0 , "When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0." );
+			animationAction.setEffectiveWeight( 0.3 );
+			assert.equal( animationAction.getEffectiveWeight(), 0, "When EffectiveWeight is set to 0.3 when disabled , EffectiveWeight is 0." );
 
 		} );
 
 		QUnit.test( "fadeIn", ( assert ) => {
 
-			var {mixer, animationAction} = createAnimation();
-			animationAction.fadeIn(1000);
+			var { mixer, animationAction } = createAnimation();
+			animationAction.fadeIn( 1000 );
 			animationAction.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation fadeIn is started, EffectiveWeight is 1." );
-			mixer.update(250);
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeIn is started, EffectiveWeight is 1." );
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeIn happened 1/4, EffectiveWeight is 0.25." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeIn is halfway , EffectiveWeight is 0.5." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeIn is halfway , EffectiveWeight is 0.75." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeIn is ended , EffectiveWeight is 1." );
 
 		} );
 
 		QUnit.test( "fadeOut", ( assert ) => {
 
-			var {mixer, animationAction} = createAnimation();
-			animationAction.fadeOut(1000);
+			var { mixer, animationAction } = createAnimation();
+			animationAction.fadeOut( 1000 );
 			animationAction.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation fadeOut is started, EffectiveWeight is 1." );
-			mixer.update(250);
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeOut is started, EffectiveWeight is 1." );
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeOut is halfway , EffectiveWeight is 0.5." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.equal( animationAction.getEffectiveWeight(), 0, "When an animation fadeOut is ended , EffectiveWeight is 0." );
 
 		} );
 
 		QUnit.test( "crossFadeFrom", ( assert ) => {
 
-			var {mixer, animationAction, animationAction2} = createTwoAnimations();
-			animationAction.crossFadeFrom(animationAction2, 1000, false);
+			var { mixer, animationAction, animationAction2 } = createTwoAnimations();
+			animationAction.crossFadeFrom( animationAction2, 1000, false );
 			animationAction.play();
 			animationAction2.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
-			assert.equal( animationAction2.getEffectiveWeight(), 1 , "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
-			mixer.update(250);
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
+			assert.equal( animationAction2.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0.5, "When an animation fadeOut is halfway , EffectiveWeight is 0.5." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0.25, "When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0, "When an animation fadeOut is ended , EffectiveWeight is 0." );
 
@@ -358,22 +350,22 @@ export default QUnit.module( 'Animation', () => {
 
 		QUnit.test( "crossFadeTo", ( assert ) => {
 
-			var {mixer, animationAction, animationAction2} = createTwoAnimations();
-			animationAction2.crossFadeTo(animationAction, 1000, false);
+			var { mixer, animationAction, animationAction2 } = createTwoAnimations();
+			animationAction2.crossFadeTo( animationAction, 1000, false );
 			animationAction.play();
 			animationAction2.play();
-			assert.equal( animationAction.getEffectiveWeight(), 1 , "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
-			assert.equal( animationAction2.getEffectiveWeight(), 1 , "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
-			mixer.update(250);
+			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
+			assert.equal( animationAction2.getEffectiveWeight(), 1, "When an animation crossFadeFrom is started, EffectiveWeight is 1." );
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.25, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.5, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0.5, "When an animation fadeOut is halfway , EffectiveWeight is 0.5." );
-			mixer.update(250);
+			mixer.update( 250 );
 			assert.equal( animationAction.getEffectiveWeight(), 0.75, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0.25, "When an animation fadeOut is happened 3/4 , EffectiveWeight is 0.25." );
-			mixer.update(500);
+			mixer.update( 500 );
 			assert.equal( animationAction.getEffectiveWeight(), 1, "When an animation fadeOut happened 1/4, EffectiveWeight is 0.75." );
 			assert.equal( animationAction2.getEffectiveWeight(), 0, "When an animation fadeOut is ended , EffectiveWeight is 0." );
 
@@ -435,7 +427,7 @@ export default QUnit.module( 'Animation', () => {
 
 		} );
 
-		QUnit.test("getClip", (assert) => {
+		QUnit.test( "getClip", ( assert ) => {
 
 			var { clip, animationAction } = createAnimation();
 			var clip2 = animationAction.getClip();
@@ -447,7 +439,7 @@ export default QUnit.module( 'Animation', () => {
 
 			var { root, animationAction } = createAnimation();
 			var root2 = animationAction.getRoot();
-			assert.equal(root, root2, "root should be returned by getRoot." );
+			assert.equal( root, root2, "root should be returned by getRoot." );
 
 		} );
 

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

@@ -130,29 +130,6 @@ export default QUnit.module( 'Core', () => {
 
 		} );
 
-		QUnit.test( "copyIndicesArray", ( assert ) => {
-
-			var attr = new BufferAttribute( new Float32Array( 6 ), 3 );
-
-			attr.copyIndicesArray( [
-				{
-					a: 1,
-					b: 2,
-					c: 3
-				},
-				{
-					a: 4,
-					b: 5,
-					c: 6
-				}
-			] );
-
-			var i = attr.array;
-			assert.ok( i[ 0 ] === 1 && i[ 1 ] === 2 && i[ 2 ] === 3, 'first indices were copied correctly' );
-			assert.ok( i[ 3 ] === 4 && i[ 4 ] === 5 && i[ 5 ] === 6, 'second indices were copied correctly' );
-
-		} );
-
 		QUnit.test( "copyVector2sArray", ( assert ) => {
 
 			var attr = new BufferAttribute( new Float32Array( 4 ), 2 );

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

@@ -603,15 +603,6 @@ export default QUnit.module( 'Core', () => {
 
 				}
 
-				if ( geometry.indices.length > 0 ) {
-
-					var TypeArray = arrayMax( geometry.indices ) > 65535 ? Uint32Array : Uint16Array;
-					var indices = new TypeArray( geometry.indices.length * 3 );
-					attr = new BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices );
-					assert.ok( bufferAttributeEquals( a.indices, attr ), "Indices are identical" );
-
-				}
-
 				// groups
 				assert.deepEqual( a.groups, geometry.groups, "Groups are identical" );
 
@@ -657,9 +648,6 @@ export default QUnit.module( 'Core', () => {
 
 				}
 
-				// TODO
-				// DirectGeometry doesn't actually copy boundingSphere and boundingBox yet,
-				// so they're always null
 				if ( geometry.boundingSphere !== null ) {
 
 					assert.ok( a.boundingSphere.equals( geometry.boundingSphere ), "BoundingSphere is identical" );

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

@@ -16,7 +16,7 @@ export default QUnit.module( 'Extras', () => {
 
 		} );
 
-		QUnit.todo( "triangulate", ( assert ) => {
+		QUnit.todo( "isClockWise", ( assert ) => {
 
 			assert.ok( false, "everything's gonna be alright" );
 
@@ -28,12 +28,6 @@ export default QUnit.module( 'Extras', () => {
 
 		} );
 
-		QUnit.todo( "isClockWise", ( assert ) => {
-
-			assert.ok( false, "everything's gonna be alright" );
-
-		} );
-
 	} );
 
 } );

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

@@ -54,7 +54,7 @@ export default QUnit.module( 'Extras', () => {
 			QUnit.test( "catmullrom check", ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				curve.curveType = 'catmullrom';
 
 				var expectedPoints = [
 
@@ -90,7 +90,7 @@ export default QUnit.module( 'Extras', () => {
 
 				var curve = new CatmullRomCurve3( positions );
 
-				curve.type = 'chordal';
+				curve.curveType = 'chordal';
 
 				var expectedPoints = [
 					new Vector3( - 60, - 100, 60 ),
@@ -123,7 +123,7 @@ export default QUnit.module( 'Extras', () => {
 			QUnit.test( "centripetal basic check", ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
-				curve.type = 'centripetal';
+				curve.curveType = 'centripetal';
 
 				var expectedPoints = [
 					new Vector3( - 60, - 100, 60 ),
@@ -156,7 +156,7 @@ export default QUnit.module( 'Extras', () => {
 			QUnit.test( "closed catmullrom basic check", ( assert ) => {
 
 				var curve = new CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				curve.curveType = 'catmullrom';
 				curve.closed = true;
 
 				var expectedPoints = [
@@ -192,8 +192,8 @@ export default QUnit.module( 'Extras', () => {
 			//
 			QUnit.test( "getLength/getLengths", ( assert ) => {
 
-				var curve = new THREE.CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				var curve = new CatmullRomCurve3( positions );
+				curve.curveType = 'catmullrom';
 
 				var length = curve.getLength();
 				var expectedLength = 551.549686276872;
@@ -221,14 +221,14 @@ export default QUnit.module( 'Extras', () => {
 
 			QUnit.test( "getPointAt", ( assert ) => {
 
-				var curve = new THREE.CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				var curve = new CatmullRomCurve3( positions );
+				curve.curveType = 'catmullrom';
 
 				var expectedPoints = [
-					new THREE.Vector3( - 60, - 100, 60 ),
-					new THREE.Vector3( - 64.84177333183106, 64.86956465359813, 64.84177333183106 ),
-					new THREE.Vector3( - 28.288507045700854, 104.83101184518996, 28.288507045700854 ),
-					new THREE.Vector3( 60, - 100, - 60 )
+					new Vector3( - 60, - 100, 60 ),
+					new Vector3( - 64.84177333183106, 64.86956465359813, 64.84177333183106 ),
+					new Vector3( - 28.288507045700854, 104.83101184518996, 28.288507045700854 ),
+					new Vector3( 60, - 100, - 60 )
 				];
 
 				var points = [
@@ -244,15 +244,15 @@ export default QUnit.module( 'Extras', () => {
 
 			QUnit.test( "getTangent/getTangentAt", ( assert ) => {
 
-				var curve = new THREE.CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				var curve = new CatmullRomCurve3( positions );
+				curve.curveType = 'catmullrom';
 
 				var expectedTangents = [
-					new THREE.Vector3( 0, 1, 0 ),
-					new THREE.Vector3( - 0.0001090274561657922, 0.9999999881130137, 0.0001090274561657922 ),
-					new THREE.Vector3( 0.7071067811865475, - 2.0930381713877622e-13, - 0.7071067811865475 ),
-					new THREE.Vector3( 0.43189437062802816, - 0.7917919583070032, - 0.43189437062802816 ),
-					new THREE.Vector3( - 0.00019991333100812723, - 0.9999999600346592, 0.00019991333100812723 )
+					new Vector3( 0, 1, 0 ),
+					new Vector3( - 0.0001090274561657922, 0.9999999881130137, 0.0001090274561657922 ),
+					new Vector3( 0.7071067811865475, - 2.0930381713877622e-13, - 0.7071067811865475 ),
+					new Vector3( 0.43189437062802816, - 0.7917919583070032, - 0.43189437062802816 ),
+					new Vector3( - 0.00019991333100812723, - 0.9999999600346592, 0.00019991333100812723 )
 				];
 
 				var tangents = [
@@ -275,11 +275,11 @@ export default QUnit.module( 'Extras', () => {
 				//
 
 				var expectedTangents = [
-					new THREE.Vector3( 0, 1, 0 ),
-					new THREE.Vector3( - 0.10709018822205997, 0.9884651653817284, 0.10709018822205997 ),
-					new THREE.Vector3( 0.6396363672964268, - 0.4262987629159402, - 0.6396363672964268 ),
-					new THREE.Vector3( 0.5077298411616501, - 0.6960034603275557, - 0.5077298411616501 ),
-					new THREE.Vector3( - 0.00019991333100812723, - 0.9999999600346592, 0.00019991333100812723 )
+					new Vector3( 0, 1, 0 ),
+					new Vector3( - 0.10709018822205997, 0.9884651653817284, 0.10709018822205997 ),
+					new Vector3( 0.6396363672964268, - 0.4262987629159402, - 0.6396363672964268 ),
+					new Vector3( 0.5077298411616501, - 0.6960034603275557, - 0.5077298411616501 ),
+					new Vector3( - 0.00019991333100812723, - 0.9999999600346592, 0.00019991333100812723 )
 				];
 
 				var tangents = [
@@ -303,24 +303,24 @@ export default QUnit.module( 'Extras', () => {
 
 			QUnit.test( "computeFrenetFrames", ( assert ) => {
 
-				var curve = new THREE.CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				var curve = new CatmullRomCurve3( positions );
+				curve.curveType = 'catmullrom';
 
 				var expected = {
 					binormals: [
-						new THREE.Vector3( - 1, 0, 0 ),
-						new THREE.Vector3( - 0.28685061854203, 0.6396363672964267, - 0.7131493814579701 ),
-						new THREE.Vector3( - 1.9982670528160395e-8, - 0.0001999133310081272, - 0.9999999800173295 )
+						new Vector3( - 1, 0, 0 ),
+						new Vector3( - 0.28685061854203, 0.6396363672964267, - 0.7131493814579701 ),
+						new Vector3( - 1.9982670528160395e-8, - 0.0001999133310081272, - 0.9999999800173295 )
 					],
 					normals: [
-						new THREE.Vector3( 0, 0, - 1 ),
-						new THREE.Vector3( - 0.7131493814579699, - 0.6396363672964268, - 0.2868506185420297 ),
-						new THREE.Vector3( - 0.9999999800173294, 0.00019991333100810582, - 1.99826701852146e-8 )
+						new Vector3( 0, 0, - 1 ),
+						new Vector3( - 0.7131493814579699, - 0.6396363672964268, - 0.2868506185420297 ),
+						new Vector3( - 0.9999999800173294, 0.00019991333100810582, - 1.99826701852146e-8 )
 					],
 					tangents: [
-						new THREE.Vector3( 0, 1, 0 ),
-						new THREE.Vector3( 0.6396363672964269, - 0.4262987629159403, - 0.6396363672964269 ),
-						new THREE.Vector3( - 0.0001999133310081273, - 0.9999999600346594, 0.0001999133310081273 )
+						new Vector3( 0, 1, 0 ),
+						new Vector3( 0.6396363672964269, - 0.4262987629159403, - 0.6396363672964269 ),
+						new Vector3( - 0.0001999133310081273, - 0.9999999600346594, 0.0001999133310081273 )
 					]
 				};
 
@@ -342,8 +342,8 @@ export default QUnit.module( 'Extras', () => {
 
 			QUnit.test( "getUtoTmapping", ( assert ) => {
 
-				var curve = new THREE.CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				var curve = new CatmullRomCurve3( positions );
+				curve.curveType = 'catmullrom';
 
 				var start = curve.getUtoTmapping( 0, 0 );
 				var end = curve.getUtoTmapping( 0, curve.getLength() );
@@ -359,16 +359,16 @@ export default QUnit.module( 'Extras', () => {
 
 			QUnit.test( "getSpacedPoints", ( assert ) => {
 
-				var curve = new THREE.CatmullRomCurve3( positions );
-				curve.type = 'catmullrom';
+				var curve = new CatmullRomCurve3( positions );
+				curve.curveType = 'catmullrom';
 
 				var expectedPoints = [
-					new THREE.Vector3( - 60, - 100, 60 ),
-					new THREE.Vector3( - 60, 10.311489426555056, 60 ),
-					new THREE.Vector3( - 65.05889864636504, 117.99691802595966, 65.05889864636504 ),
-					new THREE.Vector3( 6.054276900088592, 78.7153118386369, - 6.054276900088592 ),
-					new THREE.Vector3( 64.9991491385602, 8.386980812799566, - 64.9991491385602 ),
-					new THREE.Vector3( 60, - 100, - 60 )
+					new Vector3( - 60, - 100, 60 ),
+					new Vector3( - 60, 10.311489426555056, 60 ),
+					new Vector3( - 65.05889864636504, 117.99691802595966, 65.05889864636504 ),
+					new Vector3( 6.054276900088592, 78.7153118386369, - 6.054276900088592 ),
+					new Vector3( 64.9991491385602, 8.386980812799566, - 64.9991491385602 ),
+					new Vector3( 60, - 100, - 60 )
 				];
 
 				var points = curve.getSpacedPoints();

test/unit/src/math/Quaternion.tests.js

@@ -406,26 +406,6 @@ export default QUnit.module( 'Maths', () => {
 
 		} );
 
-		QUnit.test( "inverse", ( assert ) => {
-
-			assert.expect( 6 );
-
-			var a = new Quaternion( x, y, z, w );
-			var inverted = new Quaternion( - 0.2721655269759087, - 0.408248290463863, - 0.5443310539518174, 0.6804138174397717 );
-			a.onChange( function () {
-
-				assert.ok( true, "onChange called" );
-
-			} );
-
-			a.inverse();
-			assert.ok( Math.abs( a.x - inverted.x ) <= eps, "Check x" );
-			assert.ok( Math.abs( a.y - inverted.y ) <= eps, "Check y" );
-			assert.ok( Math.abs( a.z - inverted.z ) <= eps, "Check z" );
-			assert.ok( Math.abs( a.w - inverted.w ) <= eps, "Check w" );
-
-		} );
-
 		QUnit.todo( "dot", ( assert ) => {
 
 			assert.ok( false, "everything's gonna be alright" );
@@ -435,7 +415,6 @@ export default QUnit.module( 'Maths', () => {
 		QUnit.test( "normalize/length/lengthSq", ( assert ) => {
 
 			var a = new Quaternion( x, y, z, w );
-			var b = new Quaternion( - x, - y, - z, - w );
 
 			assert.ok( a.length() != 1, "Passed!" );
 			assert.ok( a.lengthSq() != 1, "Passed!" );