Add geometries es6 unit tests

test/unit/src/geometries/BoxGeometry.tests.js

@@ -0,0 +1,104 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	BoxGeometry,
+	BoxBufferGeometry
+} from '../../../../src/geometries/BoxGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'BoxGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				width: 10,
+				height: 20,
+				depth: 30,
+				widthSegments: 2,
+				heightSegments: 3,
+				depthSegments: 4
+			};
+
+			geometries = [
+				new BoxGeometry(),
+				new BoxGeometry( parameters.width, parameters.height, parameters.depth ),
+				new BoxGeometry( parameters.width, parameters.height, parameters.depth, parameters.widthSegments, parameters.heightSegments, parameters.depthSegments )
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'BoxBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				width: 10,
+				height: 20,
+				depth: 30,
+				widthSegments: 2,
+				heightSegments: 3,
+				depthSegments: 4
+			};
+
+			geometries = [
+				new BoxBufferGeometry(),
+				new BoxBufferGeometry( parameters.width, parameters.height, parameters.depth ),
+				new BoxBufferGeometry( parameters.width, parameters.height, parameters.depth, parameters.widthSegments, parameters.heightSegments, parameters.depthSegments )
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/CircleGeometry.tests.js

@@ -0,0 +1,104 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	CircleGeometry,
+	CircleBufferGeometry
+} from '../../../../src/geometries/CircleGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'CircleGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				segments: 20,
+				thetaStart: 0.1,
+				thetaLength: 0.2
+			};
+
+			geometries = [
+				new CircleGeometry(),
+				new CircleGeometry( parameters.radius ),
+				new CircleGeometry( parameters.radius, parameters.segments ),
+				new CircleGeometry( parameters.radius, parameters.segments, parameters.thetaStart ),
+				new CircleGeometry( parameters.radius, parameters.segments, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'CircleBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				segments: 20,
+				thetaStart: 0.1,
+				thetaLength: 0.2
+			};
+
+			geometries = [
+				new CircleBufferGeometry(),
+				new CircleBufferGeometry( parameters.radius ),
+				new CircleBufferGeometry( parameters.radius, parameters.segments ),
+				new CircleBufferGeometry( parameters.radius, parameters.segments, parameters.thetaStart ),
+				new CircleBufferGeometry( parameters.radius, parameters.segments, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/ConeGeometry.tests.js

@@ -0,0 +1,85 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	ConeGeometry,
+	ConeBufferGeometry
+} from '../../../../src/geometries/ConeGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'ConeGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new ConeGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'ConeBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new ConeBufferGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/CylinderGeometry.tests.js

@@ -0,0 +1,120 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	CylinderGeometry,
+	CylinderBufferGeometry
+} from '../../../../src/geometries/CylinderGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'CylinderGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radiusTop: 10,
+				radiusBottom: 20,
+				height: 30,
+				radialSegments: 20,
+				heightSegments: 30,
+				openEnded: true,
+				thetaStart: 0.1,
+				thetaLength: 2.0,
+			};
+
+			geometries = [
+				new CylinderGeometry(),
+				new CylinderGeometry( parameters.radiusTop ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments, parameters.openEnded ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments, parameters.openEnded, parameters.thetaStart ),
+				new CylinderGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments, parameters.openEnded, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'CylinderBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radiusTop: 10,
+				radiusBottom: 20,
+				height: 30,
+				radialSegments: 20,
+				heightSegments: 30,
+				openEnded: true,
+				thetaStart: 0.1,
+				thetaLength: 2.0,
+			};
+
+			geometries = [
+				new CylinderBufferGeometry(),
+				new CylinderBufferGeometry( parameters.radiusTop ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments, parameters.openEnded ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments, parameters.openEnded, parameters.thetaStart ),
+				new CylinderBufferGeometry( parameters.radiusTop, parameters.radiusBottom, parameters.height, parameters.radialSegments, parameters.heightSegments, parameters.openEnded, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/DodecahedronGeometry.tests.js

@@ -0,0 +1,96 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	DodecahedronGeometry,
+	DodecahedronBufferGeometry
+} from '../../../../src/geometries/DodecahedronGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'CircleGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new DodecahedronGeometry(),
+				new DodecahedronGeometry( parameters.radius ),
+				new DodecahedronGeometry( parameters.radius, parameters.detail ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'CircleBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new DodecahedronBufferGeometry(),
+				new DodecahedronBufferGeometry( parameters.radius ),
+				new DodecahedronBufferGeometry( parameters.radius, parameters.detail ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/EdgesGeometry.tests.js

@@ -0,0 +1,310 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import { EdgesGeometry } from '../../../../src/geometries/EdgesGeometry';
+import { Geometry } from '../../../../src/core/Geometry';
+import { BufferGeometry } from '../../../../src/core/BufferGeometry';
+import { BufferAttribute } from '../../../../src/core/BufferAttribute';
+import { Vector3 } from '../../../../src/math/Vector3';
+
+// DEBUGGING
+import { Scene } from '../../../../src/scenes/Scene';
+import { Mesh } from '../../../../src/objects/Mesh';
+import { LineSegments } from '../../../../src/objects/LineSegments';
+import { LineBasicMaterial } from '../../../../src/materials/LineBasicMaterial';
+import { WebGLRenderer } from '../../../../src/renderers/WebGLRenderer';
+import { PerspectiveCamera } from '../../../../src/cameras/PerspectiveCamera';
+
+//
+// HELPERS
+//
+
+function testEdges( vertList, idxList, numAfter, assert ) {
+
+	var geoms = createGeometries( vertList, idxList );
+
+	for ( var i = 0; i < geoms.length; i ++ ) {
+
+		var geom = geoms[ i ];
+
+		var numBefore = idxList.length;
+		assert.equal( countEdges( geom ), numBefore, "Edges before!" );
+
+		var egeom = new EdgesGeometry( geom );
+
+		assert.equal( countEdges( egeom ), numAfter, "Edges after!" );
+		output( geom, egeom );
+
+	}
+
+}
+
+function createGeometries( vertList, idxList ) {
+
+	var geomIB = createIndexedBufferGeometry( vertList, idxList );
+	var geom = new Geometry().fromBufferGeometry( geomIB );
+	var geomB = new BufferGeometry().fromGeometry( geom );
+	var geomDC = addDrawCalls( geomIB.clone() );
+	return [ geom, geomB, geomIB, geomDC ];
+
+}
+
+function createIndexedBufferGeometry( vertList, idxList ) {
+
+	var geom = new BufferGeometry();
+
+	var indexTable = [];
+	var numTris = idxList.length / 3;
+	var numVerts = 0;
+
+	var indices = new Uint32Array( numTris * 3 );
+	var vertices = new Float32Array( vertList.length * 3 );
+
+	for ( var i = 0; i < numTris; i ++ ) {
+
+		for ( var j = 0; j < 3; j ++ ) {
+
+			var idx = idxList[ 3 * i + j ];
+			if ( indexTable[ idx ] === undefined ) {
+
+				var v = vertList[ idx ];
+				vertices[ 3 * numVerts ] = v.x;
+				vertices[ 3 * numVerts + 1 ] = v.y;
+				vertices[ 3 * numVerts + 2 ] = v.z;
+
+				indexTable[ idx ] = numVerts;
+
+				numVerts ++;
+
+			}
+
+			indices[ 3 * i + j ] = indexTable[ idx ];
+
+		}
+
+	}
+
+	vertices = vertices.subarray( 0, 3 * numVerts );
+
+	geom.setIndex( new BufferAttribute( indices, 1 ) );
+	geom.addAttribute( 'position', new BufferAttribute( vertices, 3 ) );
+
+	geom.computeFaceNormals();
+
+	return geom;
+
+}
+
+function addDrawCalls( geometry ) {
+
+	var numTris = geometry.index.count / 3;
+
+	for ( var i = 0; i < numTris; i ++ ) {
+
+		var start = i * 3;
+		var count = 3;
+
+		geometry.addGroup( start, count );
+
+	}
+
+	return geometry;
+
+}
+
+function countEdges( geom ) {
+
+	if ( geom instanceof EdgesGeometry ) {
+
+		return geom.getAttribute( 'position' ).count / 2;
+
+	}
+
+	if ( geom.faces !== undefined ) {
+
+		return geom.faces.length * 3;
+
+	}
+
+	var indices = geom.index;
+	if ( indices ) {
+
+		return indices.count;
+
+	}
+
+	return geom.getAttribute( 'position' ).count;
+
+}
+
+//
+// DEBUGGING
+//
+var DEBUG = false;
+var renderer;
+var camera;
+var scene = new Scene();
+var xoffset = 0;
+
+function output( geom, egeom ) {
+
+	if ( DEBUG !== true ) return;
+
+	if ( ! renderer ) initDebug();
+
+	var mesh = new Mesh( geom, undefined );
+	var edges = new LineSegments( egeom, new LineBasicMaterial( { color: 'black' } ) );
+
+	mesh.position.setX( xoffset );
+	edges.position.setX( xoffset ++ );
+	scene.add( mesh );
+	scene.add( edges );
+
+	if ( scene.children.length % 8 === 0 ) {
+
+		xoffset += 2;
+
+	}
+
+}
+
+function initDebug() {
+
+	renderer = new WebGLRenderer( {
+
+		antialias: true
+
+	} );
+
+	var width = 600;
+	var height = 480;
+
+	renderer.setSize( width, height );
+	renderer.setClearColor( 0xCCCCCC );
+
+	camera = new PerspectiveCamera( 45, width / height, 1, 100 );
+	camera.position.x = 30;
+	camera.position.z = 40;
+	camera.lookAt( new Vector3( 30, 0, 0 ) );
+
+	document.body.appendChild( renderer.domElement );
+
+	var controls = new THREE.OrbitControls( camera, renderer.domElement ); // TODO: please do somethings for that -_-'
+	controls.target = new Vector3( 30, 0, 0 );
+
+	animate();
+
+	function animate() {
+
+		requestAnimationFrame( animate );
+
+		controls.update();
+
+		renderer.render( scene, camera );
+
+	}
+
+}
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'EdgesGeometry', () => {
+
+		var vertList = [
+			new Vector3( 0, 0, 0 ),
+			new Vector3( 1, 0, 0 ),
+			new Vector3( 1, 1, 0 ),
+			new Vector3( 0, 1, 0 ),
+			new Vector3( 1, 1, 1 ),
+		];
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( "singularity", ( assert ) => {
+
+			testEdges( vertList, [ 1, 1, 1 ], 0, assert );
+
+		} );
+
+		QUnit.test( "needle", ( assert ) => {
+
+			testEdges( vertList, [ 0, 0, 1 ], 0, assert );
+
+		} );
+
+		QUnit.test( "single triangle", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2 ], 3, assert );
+
+		} );
+
+		QUnit.test( "two isolated triangles", ( assert ) => {
+
+			var vertList = [
+				new Vector3( 0, 0, 0 ),
+				new Vector3( 1, 0, 0 ),
+				new Vector3( 1, 1, 0 ),
+				new Vector3( 0, 0, 1 ),
+				new Vector3( 1, 0, 1 ),
+				new Vector3( 1, 1, 1 ),
+			];
+
+			testEdges( vertList, [ 0, 1, 2, 3, 4, 5 ], 6, assert );
+
+		} );
+
+		QUnit.test( "two flat triangles", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2, 0, 2, 3 ], 4, assert );
+
+		} );
+
+		QUnit.test( "two flat triangles, inverted", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2, 0, 3, 2 ], 5, assert );
+
+		} );
+
+		QUnit.test( "two non-coplanar triangles", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2, 0, 4, 2 ], 5, assert );
+
+		} );
+
+		QUnit.test( "three triangles, coplanar first", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2, 0, 2, 3, 0, 4, 2 ], 7, assert );
+
+		} );
+
+		QUnit.test( "three triangles, coplanar last", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2, 0, 4, 2, 0, 2, 3 ], 6, assert ); // Should be 7
+
+		} );
+
+		QUnit.test( "tetrahedron", ( assert ) => {
+
+			testEdges( vertList, [ 0, 1, 2, 0, 1, 4, 0, 4, 2, 1, 2, 4 ], 6, assert );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/ExtrudeGeometry.tests.js

@@ -0,0 +1,76 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { ExtrudeGeometry, ExtrudeBufferGeometry } from '../../../../src/geometries/ExtrudeGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'ExtrudeGeometry', () => {
+
+		// 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" );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'ExtrudeBufferGeometry', () => {
+
+		// 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" );
+
+		} );
+
+		// STATIC STUFF
+		QUnit.test( "WorldUVGenerator.generateTopUV", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+		QUnit.test( "WorldUVGenerator.generateSideWallUV", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( "getArrays", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+		QUnit.test( "addShapeList", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+		QUnit.test( "addShape", ( assert ) => {
+
+			assert.ok( false, "everything's gonna be alright" );
+
+		} );
+
+
+	} );
+
+} );

test/unit/src/geometries/IcosahedronGeometry.tests.js

@@ -0,0 +1,96 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	IcosahedronGeometry,
+	IcosahedronBufferGeometry
+} from '../../../../src/geometries/IcosahedronGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'IcosahedronGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new IcosahedronGeometry(),
+				new IcosahedronGeometry( parameters.radius ),
+				new IcosahedronGeometry( parameters.radius, parameters.detail ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'IcosahedronBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new IcosahedronBufferGeometry(),
+				new IcosahedronBufferGeometry( parameters.radius ),
+				new IcosahedronBufferGeometry( parameters.radius, parameters.detail ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/LatheGeometry.tests.js

@@ -0,0 +1,97 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	LatheGeometry,
+	LatheBufferGeometry
+} from '../../../../src/geometries/LatheGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'LatheGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				points: [],
+				segments: 0,
+				phiStart: 0,
+				phiLength: 0
+			};
+
+			geometries = [
+				//				new LatheGeometry(), // Todo: error for undefined point
+				new LatheGeometry( parameters.points )
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'LatheBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				points: [],
+				segments: 0,
+				phiStart: 0,
+				phiLength: 0
+			};
+
+			geometries = [
+				//				new LatheBufferGeometry(), // Todo: error for undefined point
+				new LatheBufferGeometry( parameters.points )
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/OctahedronGeometry.tests.js

@@ -0,0 +1,96 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	OctahedronGeometry,
+	OctahedronBufferGeometry
+} from '../../../../src/geometries/OctahedronGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'OctahedronGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new OctahedronGeometry(),
+				new OctahedronGeometry( parameters.radius ),
+				new OctahedronGeometry( parameters.radius, parameters.detail ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'OctahedronBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new OctahedronBufferGeometry(),
+				new OctahedronBufferGeometry( parameters.radius ),
+				new OctahedronBufferGeometry( parameters.radius, parameters.detail ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/ParametricGeometry.tests.js

@@ -0,0 +1,85 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	ParametricGeometry,
+	ParametricBufferGeometry
+} from '../../../../src/geometries/ParametricGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'ParametricGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new ParametricGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'ParametricBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new ParametricBufferGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/PlaneGeometry.tests.js

@@ -0,0 +1,104 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	PlaneGeometry,
+	PlaneBufferGeometry
+} from '../../../../src/geometries/PlaneGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'PlaneGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				width: 10,
+				height: 30,
+				widthSegments: 3,
+				heightSegments: 5
+			};
+
+			geometries = [
+				new PlaneGeometry(),
+				new PlaneGeometry( parameters.width ),
+				new PlaneGeometry( parameters.width, parameters.height ),
+				new PlaneGeometry( parameters.width, parameters.height, parameters.widthSegments ),
+				new PlaneGeometry( parameters.width, parameters.height, parameters.widthSegments, parameters.heightSegments ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'PlaneBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				width: 10,
+				height: 30,
+				widthSegments: 3,
+				heightSegments: 5
+			};
+
+			geometries = [
+				new PlaneBufferGeometry(),
+				new PlaneBufferGeometry( parameters.width ),
+				new PlaneBufferGeometry( parameters.width, parameters.height ),
+				new PlaneBufferGeometry( parameters.width, parameters.height, parameters.widthSegments ),
+				new PlaneBufferGeometry( parameters.width, parameters.height, parameters.widthSegments, parameters.heightSegments ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/PolyhedronGeometry.tests.js

@@ -0,0 +1,85 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	PolyhedronGeometry,
+	PolyhedronBufferGeometry
+} from '../../../../src/geometries/PolyhedronGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'PolyhedronGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new PolyhedronGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'PolyhedronBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new PolyhedronBufferGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/RingGeometry.tests.js

@@ -0,0 +1,112 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	RingGeometry,
+	RingBufferGeometry
+} from '../../../../src/geometries/RingGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'RingGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				innerRadius: 10,
+				outerRadius: 60,
+				thetaSegments: 12,
+				phiSegments: 14,
+				thetaStart: 0.1,
+				thetaLength: 2.0
+			};
+
+			geometries = [
+				new RingGeometry(),
+				new RingGeometry( parameters.innerRadius ),
+				new RingGeometry( parameters.innerRadius, parameters.outerRadius ),
+				new RingGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments ),
+				new RingGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments, parameters.phiSegments ),
+				new RingGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments, parameters.phiSegments, parameters.thetaStart ),
+				new RingGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments, parameters.phiSegments, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'RingBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				innerRadius: 10,
+				outerRadius: 60,
+				thetaSegments: 12,
+				phiSegments: 14,
+				thetaStart: 0.1,
+				thetaLength: 2.0
+			};
+
+			geometries = [
+				new RingBufferGeometry(),
+				new RingBufferGeometry( parameters.innerRadius ),
+				new RingBufferGeometry( parameters.innerRadius, parameters.outerRadius ),
+				new RingBufferGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments ),
+				new RingBufferGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments, parameters.phiSegments ),
+				new RingBufferGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments, parameters.phiSegments, parameters.thetaStart ),
+				new RingBufferGeometry( parameters.innerRadius, parameters.outerRadius, parameters.thetaSegments, parameters.phiSegments, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/ShapeGeometry.tests.js

@@ -0,0 +1,85 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	ShapeGeometry,
+	ShapeBufferGeometry
+} from '../../../../src/geometries/ShapeGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'ShapeGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new ShapeGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'ShapeBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new ShapeBufferGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/SphereGeometry.tests.js

@@ -0,0 +1,116 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	SphereGeometry,
+	SphereBufferGeometry
+} from '../../../../src/geometries/SphereGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'SphereGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				widthSegments: 20,
+				heightSegments: 30,
+				phiStart: 0.5,
+				phiLength: 1.0,
+				thetaStart: 0.4,
+				thetaLength: 2.0,
+			};
+
+			geometries = [
+				new SphereGeometry(),
+				new SphereGeometry( parameters.radius ),
+				new SphereGeometry( parameters.radius, parameters.widthSegments ),
+				new SphereGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments ),
+				new SphereGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart ),
+				new SphereGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength ),
+				new SphereGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart ),
+				new SphereGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'SphereBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				widthSegments: 20,
+				heightSegments: 30,
+				phiStart: 0.5,
+				phiLength: 1.0,
+				thetaStart: 0.4,
+				thetaLength: 2.0,
+			};
+
+			geometries = [
+				new SphereBufferGeometry(),
+				new SphereBufferGeometry( parameters.radius ),
+				new SphereBufferGeometry( parameters.radius, parameters.widthSegments ),
+				new SphereBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments ),
+				new SphereBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart ),
+				new SphereBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength ),
+				new SphereBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart ),
+				new SphereBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/TetrahedronGeometry.tests.js

@@ -0,0 +1,106 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	TetrahedronGeometry,
+	TetrahedronBufferGeometry
+} from '../../../../src/geometries/TetrahedronGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'TetrahedronGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new TetrahedronGeometry(),
+				new TetrahedronGeometry( parameters.radius ),
+				new TetrahedronGeometry( parameters.radius, parameters.widthSegments ),
+				new TetrahedronGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments ),
+				new TetrahedronGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart ),
+				new TetrahedronGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength ),
+				new TetrahedronGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart ),
+				new TetrahedronGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'SphereBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				detail: undefined
+			};
+
+			geometries = [
+				new TetrahedronBufferGeometry(),
+				new TetrahedronBufferGeometry( parameters.radius ),
+				new TetrahedronBufferGeometry( parameters.radius, parameters.widthSegments ),
+				new TetrahedronBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments ),
+				new TetrahedronBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart ),
+				new TetrahedronBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength ),
+				new TetrahedronBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart ),
+				new TetrahedronBufferGeometry( parameters.radius, parameters.widthSegments, parameters.heightSegments, parameters.phiStart, parameters.phiLength, parameters.thetaStart, parameters.thetaLength ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/TextGeometry.tests.js

@@ -0,0 +1,88 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	TextGeometry,
+	TextBufferGeometry
+} from '../../../../src/geometries/TextGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'TextGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			// TODO: we cannot load any font from Threejs package :S
+			const parameters = {
+				font: undefined
+			};
+
+			geometries = [
+				new TextGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'TextBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new TextBufferGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/TorusGeometry.tests.js

@@ -0,0 +1,108 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	TorusGeometry,
+	TorusBufferGeometry
+} from '../../../../src/geometries/TorusGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'TorusGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				tube: 20,
+				radialSegments: 30,
+				tubularSegments: 10,
+				arc: 2.0,
+			};
+
+			geometries = [
+				new TorusGeometry(),
+				new TorusGeometry( parameters.radius ),
+				new TorusGeometry( parameters.radius, parameters.tube ),
+				new TorusGeometry( parameters.radius, parameters.tube, parameters.radialSegments ),
+				new TorusGeometry( parameters.radius, parameters.tube, parameters.radialSegments, parameters.tubularSegments ),
+				new TorusGeometry( parameters.radius, parameters.tube, parameters.radialSegments, parameters.tubularSegments, parameters.arc ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'TorusBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				tube: 20,
+				radialSegments: 30,
+				tubularSegments: 10,
+				arc: 2.0,
+			};
+
+			geometries = [
+				new TorusBufferGeometry(),
+				new TorusBufferGeometry( parameters.radius ),
+				new TorusBufferGeometry( parameters.radius, parameters.tube ),
+				new TorusBufferGeometry( parameters.radius, parameters.tube, parameters.radialSegments ),
+				new TorusBufferGeometry( parameters.radius, parameters.tube, parameters.radialSegments, parameters.tubularSegments ),
+				new TorusBufferGeometry( parameters.radius, parameters.tube, parameters.radialSegments, parameters.tubularSegments, parameters.arc ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/TorusKnotGeometry.tests.js

@@ -0,0 +1,110 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ * @author Anonymous
+ */
+/* global QUnit */
+
+import {
+	TorusKnotGeometry,
+	TorusKnotBufferGeometry
+} from '../../../../src/geometries/TorusKnotGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'SphereGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				tube: 20,
+				tubularSegments: 30,
+				radialSegments: 10,
+				p: 3,
+				q: 2
+			};
+
+			geometries = [
+				new TorusKnotGeometry(),
+				new TorusKnotGeometry( parameters.radius ),
+				new TorusKnotGeometry( parameters.radius, parameters.tube ),
+				new TorusKnotGeometry( parameters.radius, parameters.tube, parameters.tubularSegments ),
+				new TorusKnotGeometry( parameters.radius, parameters.tube, parameters.tubularSegments, parameters.radialSegments ),
+				new TorusKnotGeometry( parameters.radius, parameters.tube, parameters.tubularSegments, parameters.radialSegments, parameters.p, parameters.q ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'TorusKnotBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {
+				radius: 10,
+				tube: 20,
+				tubularSegments: 30,
+				radialSegments: 10,
+				p: 3,
+				q: 2
+			};
+
+			geometries = [
+				new TorusKnotBufferGeometry(),
+				new TorusKnotBufferGeometry( parameters.radius ),
+				new TorusKnotBufferGeometry( parameters.radius, parameters.tube ),
+				new TorusKnotBufferGeometry( parameters.radius, parameters.tube, parameters.tubularSegments ),
+				new TorusKnotBufferGeometry( parameters.radius, parameters.tube, parameters.tubularSegments, parameters.radialSegments ),
+				new TorusKnotBufferGeometry( parameters.radius, parameters.tube, parameters.tubularSegments, parameters.radialSegments, parameters.p, parameters.q ),
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/TubeGeometry.tests.js

@@ -0,0 +1,85 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import {
+	TubeGeometry,
+	TubeBufferGeometry
+} from '../../../../src/geometries/TubeGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'TubeGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new TubeGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+	QUnit.module.todo( 'TubeBufferGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new TubeBufferGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );

test/unit/src/geometries/WireframeGeometry.tests.js

@@ -0,0 +1,46 @@
+/**
+ * @author TristanVALCKE / https://github.com/Itee
+ */
+/* global QUnit */
+
+import { WireframeGeometry } from '../../../../src/geometries/WireframeGeometry';
+
+export default QUnit.module( 'Geometries', () => {
+
+	QUnit.module.todo( 'WireframeGeometry', ( hooks ) => {
+
+		var geometries = undefined;
+		hooks.beforeEach( function () {
+
+			const parameters = {};
+
+			geometries = [
+				new WireframeGeometry()
+			];
+
+		} );
+
+		// 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" );
+
+		} );
+
+		// OTHERS
+		QUnit.test( 'Standard geometry tests', ( assert ) => {
+
+			runStdGeometryTests( assert, geometries );
+
+		} );
+
+	} );
+
+} );