Add animation es6 unit tests

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

@@ -0,0 +1,229 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { AnimationAction } from '../../../../src/animation/AnimationAction';
+import { AnimationMixer } from '../../../../src/animation/AnimationMixer';
+import { AnimationClip } from '../../../../src/animation/AnimationClip';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'AnimationAction', () => {
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			var mixer = new AnimationMixer();
+			var clip = new AnimationClip();
+
+			assert.throws(
+				function () {
+
+					new AnimationAction();
+
+				},
+				new Error( "Mixer can't be null or undefined !" ),
+				"raised error instance about undefined or null mixer"
+			);
+
+			assert.throws(
+				function () {
+
+					new AnimationAction( mixer );
+
+				},
+				new Error( "Clip can't be null or undefined !" ),
+				"raised error instance about undefined or null clip"
+			);
+
+			var animationAction = new AnimationAction( mixer, clip );
+			assert.ok( animationAction, "animationAction instanciated" );
+
+		} );
+
+		// PRIVATE STUFF
+		QUnit.test( "_update", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_updateWeight", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_updateTimeScale", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_updateTime", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_setEndings", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_scheduleFading", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "play", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "stop", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "reset", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "isRunning", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "isScheduled", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "startAt", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setLoop", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setEffectiveWeight", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getEffectiveWeight", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "fadeIn", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "fadeOut", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "crossFadeFrom", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "crossFadeTo", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "stopFading", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setEffectiveTimeScale", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getEffectiveTimeScale", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setDuration", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "syncWith", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "halt", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "warp", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "stopWarping", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getMixer", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getClip", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getRoot", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );

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

@@ -0,0 +1,77 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { AnimationClip } from '../../../../src/animation/AnimationClip';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'AnimationClip', () => {
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// STATIC STUFF
+		QUnit.test( "parse", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "toJSON", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "CreateFromMorphTargetSequence", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "findByName", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "CreateClipsFromMorphTargetSequences", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "parseAnimation", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "resetDuration", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "trim", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "optimize", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );

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

@@ -0,0 +1,180 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { AnimationMixer } from '../../../../src/animation/AnimationMixer';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'AnimationMixer', () => {
+
+		// INHERITANCE
+		QUnit.test( "Extending", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PRIVATE STUFF
+		QUnit.test( "_bindAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_activateAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_deactivateAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_initMemoryManager", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_isActiveAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_addInactiveAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_removeInactiveAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_removeInactiveBindingsForAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_lendAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_takeBackAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_addInactiveBinding", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_removeInactiveBinding", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_lendBinding", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_takeBackBinding", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_lendControlInterpolant", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_takeBackControlInterpolant", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_controlInterpolantsResultBuffer", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "clipAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "existingAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "stopAllAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "update", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getRoot", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "uncacheClip", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "uncacheRoot", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "uncacheAction", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );

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

@@ -0,0 +1,163 @@
+/**
+ * @author tschw
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { AnimationObjectGroup } from '../../../../src/animation/AnimationObjectGroup';
+import { Object3D } from '../../../../src/core/Object3D';
+import { PropertyBinding } from '../../../../src/animation/PropertyBinding';
+
+export default QUnit.module( "Animation", () => {
+
+	QUnit.module.todo( "AnimationObjectGroup", () => {
+
+		var ObjectA = new Object3D(),
+			ObjectB = new Object3D(),
+			ObjectC = new Object3D(),
+
+			PathA = 'object.position',
+			PathB = 'object.rotation',
+			PathC = 'object.scale',
+
+			ParsedPathA = PropertyBinding.parseTrackName( PathA ),
+			ParsedPathB = PropertyBinding.parseTrackName( PathB ),
+			ParsedPathC = PropertyBinding.parseTrackName( PathC );
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PRIVATE STUFF
+		QUnit.test( "subscribe_", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} ); // Todo: Naming guys -_-'
+
+		QUnit.test( "unsubscribe_", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} ); // Todo: Naming guys -_-'
+
+		// PUBLIC STUFF
+		QUnit.test( "isAnimationObjectGroup", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "add", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "remove", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "uncache", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( "smoke test", ( assert ) => {
+
+			var expect = function expect( testIndex, group, bindings, path, cached, roots ) {
+
+				var rootNodes = [], pathsOk = true, nodesOk = true;
+
+				for ( var i = group.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {
+
+					if ( bindings[ i ].path !== path ) pathsOk = false;
+					rootNodes.push( bindings[ i ].rootNode );
+
+				}
+
+				for ( var i = 0, n = roots.length; i !== n; ++ i ) {
+
+					if ( rootNodes.indexOf( roots[ i ] ) === - 1 ) nodesOk = false;
+
+				}
+
+				assert.ok( pathsOk, QUnit.testIndex + " paths" );
+				assert.ok( nodesOk, QUnit.testIndex + " nodes" );
+				assert.ok( group.nCachedObjects_ === cached, QUnit.testIndex + " cache size" );
+				assert.ok( bindings.length - group.nCachedObjects_ === roots.length, QUnit.testIndex + " object count" );
+
+			};
+
+			// initial state
+
+			var groupA = new AnimationObjectGroup();
+			assert.ok( groupA instanceof AnimationObjectGroup, "constructor (w/o args)" );
+
+			var bindingsAA = groupA.subscribe_( PathA, ParsedPathA );
+			expect( 0, groupA, bindingsAA, PathA, 0, [] );
+
+			var groupB = new AnimationObjectGroup( ObjectA, ObjectB );
+			assert.ok( groupB instanceof AnimationObjectGroup, "constructor (with args)" );
+
+			var bindingsBB = groupB.subscribe_( PathB, ParsedPathB );
+			expect( 1, groupB, bindingsBB, PathB, 0, [ ObjectA, ObjectB ] );
+
+			// add
+
+			groupA.add( ObjectA, ObjectB );
+			expect( 2, groupA, bindingsAA, PathA, 0, [ ObjectA, ObjectB ] );
+
+			groupB.add( ObjectC );
+			expect( 3, groupB, bindingsBB, PathB, 0, [ ObjectA, ObjectB, ObjectC ] );
+
+			// remove
+
+			groupA.remove( ObjectA, ObjectC );
+			expect( 4, groupA, bindingsAA, PathA, 1, [ ObjectB ] );
+
+			groupB.remove( ObjectA, ObjectB, ObjectC );
+			expect( 5, groupB, bindingsBB, PathB, 3, [] );
+
+			// subscribe after re-add
+
+			groupA.add( ObjectC );
+			expect( 6, groupA, bindingsAA, PathA, 1, [ ObjectB, ObjectC ] );
+			var bindingsAC = groupA.subscribe_( PathC, ParsedPathC );
+			expect( 7, groupA, bindingsAC, PathC, 1, [ ObjectB, ObjectC ] );
+
+			// re-add after subscribe
+
+			var bindingsBC = groupB.subscribe_( PathC, ParsedPathC );
+			groupB.add( ObjectA, ObjectB );
+			expect( 8, groupB, bindingsBB, PathB, 1, [ ObjectA, ObjectB ] );
+
+			// unsubscribe
+
+			var copyOfBindingsBC = bindingsBC.slice();
+			groupB.unsubscribe_( PathC );
+			groupB.add( ObjectC );
+			assert.deepEqual( bindingsBC, copyOfBindingsBC, "no more update after unsubscribe" );
+
+			// uncache active
+
+			groupB.uncache( ObjectA );
+			expect( 9, groupB, bindingsBB, PathB, 0, [ ObjectB, ObjectC ] );
+
+			// uncache cached
+
+			groupA.uncache( ObjectA );
+			expect( 10, groupA, bindingsAC, PathC, 0, [ ObjectB, ObjectC ] );
+
+		} );
+
+	} );
+
+} );

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

@@ -0,0 +1,52 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { AnimationUtils } from '../../../../src/animation/AnimationUtils';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'AnimationUtils', () => {
+
+		// PUBLIC STUFF
+		QUnit.test( "arraySlice", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "convertArray", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "isTypedArray", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getKeyframeOrder", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "sortedArray", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "flattenJSON", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );
+

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

@@ -0,0 +1,128 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { KeyframeTrack } from '../../../../src/animation/KeyframeTrack';
+import { KeyframeTrackConstructor } from '../../../../src/animation/KeyframeTrackConstructor'; // Todo: why so pain ?
+import { KeyframeTrackPrototype } from '../../../../src/animation/KeyframeTrackPrototype'; // Todo: why so pain ?
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'KeyframeTrack', () => {
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// STATIC STUFF
+		QUnit.test( "parse", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "toJSON", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_getTrackTypeForValueTypeName", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "TimeBufferType", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "ValueBufferType", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "DefaultInterpolation", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "InterpolantFactoryMethodDiscrete", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "InterpolantFactoryMethodLinear", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "InterpolantFactoryMethodSmooth", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "setInterpolation", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getInterpolation", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getValueSize", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "shift", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "scale", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "trim", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "validate", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "optimize", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );
+

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

@@ -0,0 +1,355 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import { PropertyBinding } from '../../../../src/animation/PropertyBinding';
+import { BoxGeometry } from '../../../../src/geometries/BoxGeometry';
+import { Mesh } from '../../../../src/objects/Mesh';
+import { MeshBasicMaterial } from '../../../../src/materials/MeshBasicMaterial';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'PropertyBinding', () => {
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// STATIC STUFF
+		QUnit.test( "Composite", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "create", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( 'sanitizeNodeName', ( assert ) => {
+
+			assert.equal(
+				PropertyBinding.sanitizeNodeName( 'valid-name-123_' ),
+				'valid-name-123_',
+				'Leaves valid name intact.'
+			);
+
+			assert.equal(
+				PropertyBinding.sanitizeNodeName( 'space separated name 123_ -' ),
+				'space_separated_name_123__-',
+				'Replaces spaces with underscores.'
+			);
+
+			assert.equal(
+				PropertyBinding.sanitizeNodeName( '"invalid" name %123%_' ),
+				'invalid_name_123_',
+				'Strips invalid characters.'
+			);
+
+		} );
+
+		QUnit.test( 'parseTrackName', ( assert ) => {
+
+			var paths = [
+
+				[
+					'.property',
+					{
+						nodeName: undefined,
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'nodeName.property',
+					{
+						nodeName: 'nodeName',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'a.property',
+					{
+						nodeName: 'a',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'no.de.Name.property',
+					{
+						nodeName: 'no.de.Name',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'no.d-e.Name.property',
+					{
+						nodeName: 'no.d-e.Name',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'nodeName.property[accessor]',
+					{
+						nodeName: 'nodeName',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: 'accessor'
+					}
+				],
+
+				[
+					'nodeName.material.property[accessor]',
+					{
+						nodeName: 'nodeName',
+						objectName: 'material',
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: 'accessor'
+					}
+				],
+
+				[
+					'no.de.Name.material.property',
+					{
+						nodeName: 'no.de.Name',
+						objectName: 'material',
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'no.de.Name.material[materialIndex].property',
+					{
+						nodeName: 'no.de.Name',
+						objectName: 'material',
+						objectIndex: 'materialIndex',
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'uuid.property[accessor]',
+					{
+						nodeName: 'uuid',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: 'accessor'
+					}
+				],
+
+				[
+					'uuid.objectName[objectIndex].propertyName[propertyIndex]',
+					{
+						nodeName: 'uuid',
+						objectName: 'objectName',
+						objectIndex: 'objectIndex',
+						propertyName: 'propertyName',
+						propertyIndex: 'propertyIndex'
+					}
+				],
+
+				[
+					'parentName/nodeName.property',
+					{
+						// directoryName is currently unused.
+						nodeName: 'nodeName',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'parentName/no.de.Name.property',
+					{
+						// directoryName is currently unused.
+						nodeName: 'no.de.Name',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'parentName/parentName/nodeName.property[index]',
+					{
+						// directoryName is currently unused.
+						nodeName: 'nodeName',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'property',
+						propertyIndex: 'index'
+					}
+				],
+
+				[
+					'.bone[Armature.DEF_cog].position',
+					{
+						nodeName: undefined,
+						objectName: 'bone',
+						objectIndex: 'Armature.DEF_cog',
+						propertyName: 'position',
+						propertyIndex: undefined
+					}
+				],
+
+				[
+					'scene:helium_balloon_model:helium_balloon_model.position',
+					{
+						nodeName: 'helium_balloon_model',
+						objectName: undefined,
+						objectIndex: undefined,
+						propertyName: 'position',
+						propertyIndex: undefined
+					}
+				]
+			];
+
+			paths.forEach( function ( path ) {
+
+				assert.smartEqual(
+					PropertyBinding.parseTrackName( path[ 0 ] ),
+					path[ 1 ],
+					'Parses track name: ' + path[ 0 ]
+				);
+
+			} );
+
+		} );
+
+		QUnit.test( "findNode", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "BindingType", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "Versioning", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "GetterByBindingType", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "SetterByBindingTypeAndVersioning", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "getValue", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( 'setValue', ( assert ) => {
+
+			var paths = [
+				'.material.opacity',
+				'.material[opacity]'
+			];
+
+			paths.forEach( function ( path ) {
+
+				var originalValue = 0;
+				var expectedValue = 1;
+
+				var geometry = new BoxGeometry();
+				var material = new MeshBasicMaterial();
+				material.opacity = originalValue;
+				var mesh = new Mesh( geometry, material );
+
+				var binding = new PropertyBinding( mesh, path, null );
+				binding.bind();
+
+				assert.equal(
+					material.opacity,
+					originalValue,
+					'Sets property of material with "' + path + '" (pre-setValue)'
+				);
+
+				binding.setValue( [ expectedValue ], 0 );
+				assert.equal(
+					material.opacity,
+					expectedValue,
+					'Sets property of material with "' + path + '" (post-setValue)'
+				);
+
+			} );
+
+		} );
+
+		QUnit.test( "bind", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "unbind", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( "_getValue_unavailable", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_setValue_unavailable", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );

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

@@ -0,0 +1,66 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { PropertyMixer } from '../../../../src/animation/PropertyMixer';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module.todo( 'PropertyMixer', () => {
+
+		// INSTANCING
+		QUnit.test( "Instancing", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PRIVATE STUFF
+		QUnit.test( "_select", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_slerp", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "_lerp", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// PUBLIC STUFF
+		QUnit.test( "accumulate", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "apply", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "saveOriginalState", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		QUnit.test( "restoreOriginalState", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+	} );
+
+} );
+

test/unit/src/animation/tracks/BooleanKeyframeTrack.tests.js

@@ -0,0 +1,24 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { BooleanKeyframeTrack } from '../../../../../src/animation/tracks/BooleanKeyframeTrack';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module( 'Tracks', () => {
+
+		QUnit.module.todo( 'BooleanKeyframeTrack', () => {
+
+			QUnit.test( 'write me !', ( assert ) => {
+
+				assert.ok( false, "everything's gonna be alright" );
+
+			} );
+
+		} );
+
+	} );
+
+} );

test/unit/src/animation/tracks/ColorKeyframeTrack.tests.js

@@ -0,0 +1,24 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { ColorKeyframeTrack } from '../../../../../src/animation/tracks/ColorKeyframeTrack';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module( 'Tracks', () => {
+
+		QUnit.module.todo( 'ColorKeyframeTrack', () => {
+
+			QUnit.test( 'write me !', ( assert ) => {
+
+				assert.ok( false, "everything's gonna be alright" );
+
+			} );
+
+		} );
+
+	} );
+
+} );

test/unit/src/animation/tracks/NumberKeyframeTrack.tests.js

@@ -0,0 +1,24 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { NumberKeyframeTrack } from '../../../../../src/animation/tracks/NumberKeyframeTrack';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module( 'Tracks', () => {
+
+		QUnit.module.todo( 'NumberKeyframeTrack', () => {
+
+			QUnit.test( 'write me !', ( assert ) => {
+
+				assert.ok( false, "everything's gonna be alright" );
+
+			} );
+
+		} );
+
+	} );
+
+} );

test/unit/src/animation/tracks/QuaternionKeyframeTrack.tests.js

@@ -0,0 +1,24 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { QuaternionKeyframeTrack } from '../../../../../src/animation/tracks/QuaternionKeyframeTrack';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module( 'Tracks', () => {
+
+		QUnit.module.todo( 'QuaternionKeyframeTrack', () => {
+
+			QUnit.test( 'write me !', ( assert ) => {
+
+				assert.ok( false, "everything's gonna be alright" );
+
+			} );
+
+		} );
+
+	} );
+
+} );

test/unit/src/animation/tracks/StringKeyframeTrack.tests.js

@@ -0,0 +1,24 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { StringKeyframeTrack } from '../../../../../src/animation/tracks/StringKeyframeTrack';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module( 'Tracks', () => {
+
+		QUnit.module.todo( 'StringKeyframeTrack', () => {
+
+			QUnit.test( 'write me !', ( assert ) => {
+
+				assert.ok( false, "everything's gonna be alright" );
+
+			} );
+
+		} );
+
+	} );
+
+} );

test/unit/src/animation/tracks/VectorKeyframeTrack.tests.js

@@ -0,0 +1,24 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { VectorKeyframeTrack } from '../../../../../src/animation/tracks/VectorKeyframeTrack';
+
+export default QUnit.module( 'Animation', () => {
+
+	QUnit.module( 'Tracks', () => {
+
+		QUnit.module.todo( 'VectorKeyframeTrack', () => {
+
+			QUnit.test( 'write me !', ( assert ) => {
+
+				assert.ok( false, "everything's gonna be alright" );
+
+			} );
+
+		} );
+
+	} );
+
+} );