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/math/Quaternion.tests.js

@@ -418,7 +418,7 @@ export default QUnit.module( 'Maths', () => {
 
 			} );
 
-			a.inverse();
+			a.inverse().normalize();
 			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" );