Tests: Unit Tests for Geometries (#25399)

* Update BoxGeometry.tests.js

BoxGeometry extends from BufferGeometry
BoxGeometry.type should be BoxGeometry
Stub missing member tests.

* Update CapsuleGeometry.tests.js

CapsuleGeometry extends from LatheGeometry
CapsuleGeometry.type should be CapsuleGeometry
Stub missing member tests.

* Update CircleGeometry.tests.js

CircleGeometry extends from BufferGeometry
CircleGeometry.type should be CircleGeometry
Stub missing member tests.

* Update ConeGeometry.tests.js

ConeGeometry extends from CylinderGeometry.
ConeGeometry.type should be ConeGeometry
Stub missing member tests.

* Update CylinderGeometry.tests.js

CylinderGeometry extends from BufferGeometry
CylinderGeometry.type should be CylinderGeometry
Stub missing member tests.

* Update DodecahedronGeometry.tests.js

DodecahedronGeometry extends from PolyhedronGeometry
DodecahedronGeometry.type should be DodecahedronGeometry
Stub missing member tests.

* Update EdgesGeometry.tests.js

EdgesGeometry extends from BufferGeometry
EdgesGeometry.type should be EdgesGeometry
Stub missing member tests.
Explicit block scope for variables used in tests.

* Update ExtrudeGeometry.tests.js

ExtrudeGeometry extends from BufferGeometry
ExtrudeGeometry.type should be ExtrudeGeometry
Stub missing member tests.

* Update IcosahedronGeometry.tests.js

IcosahedronGeometry extends from PolyhedronGeometry
IcosahedronGeometry.type should be IcosahedronGeometry
Stub missing member tests.

* Update LatheGeometry.tests.js

LatheGeometry extends from BufferGeometry
LatheGeometry.type should be LatheGeometry
Stub missing member tests.

* Update OctahedronGeometry.tests.js

OctahedronGeometry extends from PolyhedronGeometry
OctahedronGeometry.type should be OctahedronGeometry
Stub missing member tests.

* Update PlaneGeometry.tests.js

PlaneGeometry extends from BufferGeometry
PlaneGeometry.type should be PlaneGeometry
Stub missing member tests.

* Update PolyhedronGeometry.tests.js

PolyhedronGeometry extends from BufferGeometry
PolyhedronGeometry.type should be PolyhedronGeometry
Stub missing member tests.

* Update RingGeometry.tests.js

RingGeometry extends from BufferGeometry
RingGeometry.type should be RingGeometry
Stub missing member tests.

* Update ShapeGeometry.tests.js

ShapeGeometry extends from BufferGeometry
ShapeGeometry.type should be ShapeGeometry
Stub missing member tests.

* Update SphereGeometry.tests.js

SphereGeometry extends from BufferGeometry
SphereGeometry.type should be SphereGeometry
Stub missing member tests.

* Update TetrahedronGeometry.tests.js

TetrahedronGeometry extends from PolyhedronGeometry
TetrahedronGeometry.type should be TetrahedronGeometry
Stub missing member tests.

* Update TorusGeometry.tests.js

TorusGeometry extends from BufferGeometry
TorusGeometry.type should be TorusGeometry
Stub missing member tests.

* Update TorusKnotGeometry.tests.js

TorusKnotGeometry extends from BufferGeometry
TorusKnotGeometry.type should be TorusKnotGeometry
Stub missing member tests.

* Update TubeGeometry.tests.js

TubeGeometry extends from BufferGeometry
TubeGeometry.type should be TubeGeometry
Stub missing member tests.

* Update WireframeGeometry.tests.js

WireframeGeometry extends from BufferGeometry
WireframeGeometry.type should be WireframeGeometry
Stub missing member tests.

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { BoxGeometry } from '../../../../src/geometries/BoxGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'BoxGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -28,9 +30,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new BoxGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'BoxGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -41,6 +47,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new BoxGeometry();
+			assert.ok(
+				object.type === 'BoxGeometry',
+				'BoxGeometry.type should be BoxGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { CapsuleGeometry } from '../../../../src/geometries/CapsuleGeometry.js';
 
+import { LatheGeometry } from '../../../../src/geometries/LatheGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'CapsuleGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -28,9 +30,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new CapsuleGeometry();
+			assert.strictEqual(
+				object instanceof LatheGeometry, true,
+				'CapsuleGeometry extends from LatheGeometry'
+			);
 
 		} );
 
@@ -41,6 +47,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new CapsuleGeometry();
+			assert.ok(
+				object.type === 'CapsuleGeometry',
+				'CapsuleGeometry.type should be CapsuleGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { CircleGeometry } from '../../../../src/geometries/CircleGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'CircleGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -28,9 +30,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new CircleGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'CircleGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -41,6 +47,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new CircleGeometry();
+			assert.ok(
+				object.type === 'CircleGeometry',
+				'CircleGeometry.type should be CircleGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { ConeGeometry } from '../../../../src/geometries/ConeGeometry.js';
 
+import { CylinderGeometry } from '../../../../src/geometries/CylinderGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'ConeGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			geometries = [
@@ -17,9 +19,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new ConeGeometry();
+			assert.strictEqual(
+				object instanceof CylinderGeometry, true,
+				'ConeGeometry extends from CylinderGeometry'
+			);
 
 		} );
 
@@ -30,6 +36,31 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new ConeGeometry();
+			assert.ok(
+				object.type === 'ConeGeometry',
+				'ConeGeometry.type should be ConeGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { CylinderGeometry } from '../../../../src/geometries/CylinderGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'CylinderGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -36,9 +38,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new CylinderGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'CylinderGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -49,6 +55,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new CylinderGeometry();
+			assert.ok(
+				object.type === 'CylinderGeometry',
+				'CylinderGeometry.type should be CylinderGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { DodecahedronGeometry } from '../../../../src/geometries/DodecahedronGeometry.js';
 
+import { PolyhedronGeometry } from '../../../../src/geometries/PolyhedronGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'DodecahedronGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -24,9 +26,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new DodecahedronGeometry();
+			assert.strictEqual(
+				object instanceof PolyhedronGeometry, true,
+				'DodecahedronGeometry extends from PolyhedronGeometry'
+			);
 
 		} );
 
@@ -37,6 +43,31 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new DodecahedronGeometry();
+			assert.ok(
+				object.type === 'DodecahedronGeometry',
+				'DodecahedronGeometry.type should be DodecahedronGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,6 +1,7 @@
 /* global QUnit */
 
 import { EdgesGeometry } from '../../../../src/geometries/EdgesGeometry.js';
+
 import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
 import { BufferAttribute } from '../../../../src/core/BufferAttribute.js';
 import { Vector3 } from '../../../../src/math/Vector3.js';
@@ -19,16 +20,16 @@ import { PerspectiveCamera } from '../../../../src/cameras/PerspectiveCamera.js'
 
 function testEdges( vertList, idxList, numAfter, assert ) {
 
-	var geoms = createGeometries( vertList, idxList );
+	const geoms = createGeometries( vertList, idxList );
 
-	for ( var i = 0; i < geoms.length; i ++ ) {
+	for ( let i = 0; i < geoms.length; i ++ ) {
 
-		var geom = geoms[ i ];
+		const geom = geoms[ i ];
 
-		var numBefore = idxList.length;
+		const numBefore = idxList.length;
 		assert.equal( countEdges( geom ), numBefore, 'Edges before!' );
 
-		var egeom = new EdgesGeometry( geom );
+		const egeom = new EdgesGeometry( geom );
 
 		assert.equal( countEdges( egeom ), numAfter, 'Edges after!' );
 		output( geom, egeom );
@@ -39,31 +40,31 @@ function testEdges( vertList, idxList, numAfter, assert ) {
 
 function createGeometries( vertList, idxList ) {
 
-	var geomIB = createIndexedBufferGeometry( vertList, idxList );
-	var geomDC = addDrawCalls( geomIB.clone() );
+	const geomIB = createIndexedBufferGeometry( vertList, idxList );
+	const geomDC = addDrawCalls( geomIB.clone() );
 	return [ geomIB, geomDC ];
 
 }
 
 function createIndexedBufferGeometry( vertList, idxList ) {
 
-	var geom = new BufferGeometry();
+	const geom = new BufferGeometry();
 
-	var indexTable = [];
-	var numTris = idxList.length / 3;
-	var numVerts = 0;
+	const indexTable = [];
+	const numTris = idxList.length / 3;
+	let numVerts = 0;
 
-	var indices = new Uint32Array( numTris * 3 );
-	var vertices = new Float32Array( vertList.length * 3 );
+	const indices = new Uint32Array( numTris * 3 );
+	let vertices = new Float32Array( vertList.length * 3 );
 
-	for ( var i = 0; i < numTris; i ++ ) {
+	for ( let i = 0; i < numTris; i ++ ) {
 
-		for ( var j = 0; j < 3; j ++ ) {
+		for ( let j = 0; j < 3; j ++ ) {
 
-			var idx = idxList[ 3 * i + j ];
+			const idx = idxList[ 3 * i + j ];
 			if ( indexTable[ idx ] === undefined ) {
 
-				var v = vertList[ idx ];
+				const v = vertList[ idx ];
 				vertices[ 3 * numVerts ] = v.x;
 				vertices[ 3 * numVerts + 1 ] = v.y;
 				vertices[ 3 * numVerts + 2 ] = v.z;
@@ -91,12 +92,12 @@ function createIndexedBufferGeometry( vertList, idxList ) {
 
 function addDrawCalls( geometry ) {
 
-	var numTris = geometry.index.count / 3;
+	const numTris = geometry.index.count / 3;
 
-	for ( var i = 0; i < numTris; i ++ ) {
+	for ( let i = 0; i < numTris; i ++ ) {
 
-		var start = i * 3;
-		var count = 3;
+		const start = i * 3;
+		const count = 3;
 
 		geometry.addGroup( start, count );
 
@@ -120,7 +121,7 @@ function countEdges( geom ) {
 
 	}
 
-	var indices = geom.index;
+	const indices = geom.index;
 	if ( indices ) {
 
 		return indices.count;
@@ -134,11 +135,11 @@ function countEdges( geom ) {
 //
 // DEBUGGING
 //
-var DEBUG = false;
-var renderer;
-var camera;
-var scene = new Scene();
-var xoffset = 0;
+const DEBUG = false;
+let renderer;
+let camera;
+const scene = new Scene();
+let xoffset = 0;
 
 function output( geom, egeom ) {
 
@@ -146,8 +147,8 @@ function output( geom, egeom ) {
 
 	if ( ! renderer ) initDebug();
 
-	var mesh = new Mesh( geom, undefined );
-	var edges = new LineSegments( egeom, new LineBasicMaterial( { color: 'black' } ) );
+	const mesh = new Mesh( geom, undefined );
+	const edges = new LineSegments( egeom, new LineBasicMaterial( { color: 'black' } ) );
 
 	mesh.position.setX( xoffset );
 	edges.position.setX( xoffset ++ );
@@ -170,8 +171,8 @@ function initDebug() {
 
 	} );
 
-	var width = 600;
-	var height = 480;
+	const width = 600;
+	const height = 480;
 
 	renderer.setSize( width, height );
 	renderer.setClearColor( 0xCCCCCC );
@@ -183,7 +184,7 @@ function initDebug() {
 
 	document.body.appendChild( renderer.domElement );
 
-	var controls = new THREE.OrbitControls( camera, renderer.domElement ); // TODO: please do somethings for that -_-'
+	const controls = new THREE.OrbitControls( camera, renderer.domElement ); // TODO: please do somethings for that -_-'
 	controls.target = new Vector3( 30, 0, 0 );
 
 	animate();
@@ -204,7 +205,7 @@ export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'EdgesGeometry', () => {
 
-		var vertList = [
+		const vertList = [
 			new Vector3( 0, 0, 0 ),
 			new Vector3( 1, 0, 0 ),
 			new Vector3( 1, 1, 0 ),
@@ -213,9 +214,13 @@ export default QUnit.module( 'Geometries', () => {
 		];
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new EdgesGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'EdgesGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -226,6 +231,23 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new EdgesGeometry();
+			assert.ok(
+				object.type === 'EdgesGeometry',
+				'EdgesGeometry.type should be EdgesGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'singularity', ( assert ) => {
 

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

@@ -1,15 +1,22 @@
 /* global QUnit */
 
-// import { ExtrudeGeometry, ExtrudeBufferGeometry } from '../../../../src/geometries/ExtrudeGeometry.js';
+import { ExtrudeGeometry } from '../../../../src/geometries/ExtrudeGeometry.js';
+
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+// import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'ExtrudeGeometry', () => {
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new ExtrudeGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'ExtrudeGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -20,6 +27,36 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new ExtrudeGeometry();
+			assert.ok(
+				object.type === 'ExtrudeGeometry',
+				'ExtrudeGeometry.type should be ExtrudeGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
 
 	} );
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { IcosahedronGeometry } from '../../../../src/geometries/IcosahedronGeometry.js';
 
+import { PolyhedronGeometry } from '../../../../src/geometries/PolyhedronGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'IcosahedronGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -24,9 +26,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new IcosahedronGeometry();
+			assert.strictEqual(
+				object instanceof PolyhedronGeometry, true,
+				'IcosahedronGeometry extends from PolyhedronGeometry'
+			);
 
 		} );
 
@@ -37,6 +43,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new IcosahedronGeometry();
+			assert.ok(
+				object.type === 'IcosahedronGeometry',
+				'IcosahedronGeometry.type should be IcosahedronGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { LatheGeometry } from '../../../../src/geometries/LatheGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'LatheGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -24,9 +26,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new LatheGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'LatheGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -37,6 +43,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new LatheGeometry();
+			assert.ok(
+				object.type === 'LatheGeometry',
+				'LatheGeometry.type should be LatheGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { OctahedronGeometry } from '../../../../src/geometries/OctahedronGeometry.js';
 
+import { PolyhedronGeometry } from '../../../../src/geometries/PolyhedronGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'OctahedronGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -24,9 +26,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new OctahedronGeometry();
+			assert.strictEqual(
+				object instanceof PolyhedronGeometry, true,
+				'OctahedronGeometry extends from PolyhedronGeometry'
+			);
 
 		} );
 
@@ -37,6 +43,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new OctahedronGeometry();
+			assert.ok(
+				object.type === 'OctahedronGeometry',
+				'OctahedronGeometry.type should be OctahedronGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { PlaneGeometry } from '../../../../src/geometries/PlaneGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'PlaneGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -28,9 +30,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new PlaneGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'PlaneGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -41,6 +47,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new PlaneGeometry();
+			assert.ok(
+				object.type === 'PlaneGeometry',
+				'PlaneGeometry.type should be PlaneGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,20 +1,22 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { PolyhedronGeometry } from '../../../../src/geometries/PolyhedronGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'PolyhedronGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
-			var vertices = [
+			const vertices = [
 				1, 1, 1, 	- 1, - 1, 1, 	- 1, 1, - 1, 	1, - 1, - 1
 			];
 
-			var indices = [
+			const indices = [
 				2, 1, 0, 	0, 3, 2,	1, 3, 0,	2, 3, 1
 			];
 
@@ -25,9 +27,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new PolyhedronGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'PolyhedronGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -38,6 +44,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new PolyhedronGeometry();
+			assert.ok(
+				object.type === 'PolyhedronGeometry',
+				'PolyhedronGeometry.type should be PolyhedronGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
+import { RingGeometry } from '../../../../src/geometries/RingGeometry.js';
+
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
 import { runStdGeometryTests } from '../../utils/qunit-utils.js';
-import { RingGeometry, } from '../../../../src/geometries/RingGeometry.js';
 
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'RingGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -32,9 +34,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new RingGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'RingGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -45,6 +51,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new RingGeometry();
+			assert.ok(
+				object.type === 'RingGeometry',
+				'RingGeometry.type should be RingGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -3,15 +3,17 @@
 import { ShapeGeometry } from '../../../../src/geometries/ShapeGeometry.js';
 
 import { Shape } from '../../../../src/extras/core/Shape.js';
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+// import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'ShapeGeometry', ( hooks ) => {
 
-		var geometries = undefined; // eslint-disable-line no-unused-vars
+		let geometries = undefined; // eslint-disable-line no-unused-vars
 		hooks.beforeEach( function () {
 
-			var triangleShape = new Shape();
+			const triangleShape = new Shape();
 			triangleShape.moveTo( 0, - 1 );
 			triangleShape.lineTo( 1, 1 );
 			triangleShape.lineTo( - 1, 1 );
@@ -23,9 +25,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new ShapeGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'ShapeGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -36,6 +42,37 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new ShapeGeometry();
+			assert.ok(
+				object.type === 'ShapeGeometry',
+				'ShapeGeometry.type should be ShapeGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.todo( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { SphereGeometry } from '../../../../src/geometries/SphereGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'SphereGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -34,9 +36,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new SphereGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'SphereGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -47,6 +53,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new SphereGeometry();
+			assert.ok(
+				object.type === 'SphereGeometry',
+				'SphereGeometry.type should be SphereGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { TetrahedronGeometry } from '../../../../src/geometries/TetrahedronGeometry.js';
 
+import { PolyhedronGeometry } from '../../../../src/geometries/PolyhedronGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'TetrahedronGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -24,9 +26,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new TetrahedronGeometry();
+			assert.strictEqual(
+				object instanceof PolyhedronGeometry, true,
+				'TetrahedronGeometry extends from PolyhedronGeometry'
+			);
 
 		} );
 
@@ -37,6 +43,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new TetrahedronGeometry();
+			assert.ok(
+				object.type === 'TetrahedronGeometry',
+				'TetrahedronGeometry.type should be TetrahedronGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { TorusGeometry } from '../../../../src/geometries/TorusGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'TorusGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -30,9 +32,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new TorusGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'TorusGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -43,6 +49,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new TorusGeometry();
+			assert.ok(
+				object.type === 'TorusGeometry',
+				'TorusGeometry.type should be TorusGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -1,13 +1,15 @@
 /* global QUnit */
 
-import { runStdGeometryTests } from '../../utils/qunit-utils.js';
 import { TorusKnotGeometry } from '../../../../src/geometries/TorusKnotGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'TorusKnotGeometry', ( hooks ) => {
 
-		var geometries = undefined;
+		let geometries = undefined;
 		hooks.beforeEach( function () {
 
 			const parameters = {
@@ -31,9 +33,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new TorusKnotGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'TorusKnotGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -44,6 +50,30 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new TorusKnotGeometry();
+			assert.ok(
+				object.type === 'TorusKnotGeometry',
+				'TorusKnotGeometry.type should be TorusKnotGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.test( 'Standard geometry tests', ( assert ) => {
 

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

@@ -5,14 +5,17 @@ import { TubeGeometry } from '../../../../src/geometries/TubeGeometry.js';
 import { LineCurve3 } from '../../../../src/extras/curves/LineCurve3.js';
 import { Vector3 } from '../../../../src/math/Vector3.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+// import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'TubeGeometry', ( hooks ) => {
 
-		var geometries = undefined; // eslint-disable-line no-unused-vars
+		let geometries = undefined; // eslint-disable-line no-unused-vars
 		hooks.beforeEach( function () {
 
-			var path = new LineCurve3( new Vector3( 0, 0, 0 ), new Vector3( 0, 1, 0 ) );
+			const path = new LineCurve3( new Vector3( 0, 0, 0 ), new Vector3( 0, 1, 0 ) );
 
 			geometries = [
 				new TubeGeometry( path ),
@@ -21,9 +24,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new TubeGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'TubeGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -34,6 +41,55 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new TubeGeometry();
+			assert.ok(
+				object.type === 'TubeGeometry',
+				'TubeGeometry.type should be TubeGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'tangents', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'normals', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		QUnit.todo( 'binormals', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// PUBLIC
+		QUnit.todo( 'toJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
+		// STATIC
+		QUnit.todo( 'fromJSON', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.todo( 'Standard geometry tests', ( assert ) => {
 

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

@@ -2,11 +2,14 @@
 
 import { WireframeGeometry } from '../../../../src/geometries/WireframeGeometry.js';
 
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+// import { runStdGeometryTests } from '../../utils/qunit-utils.js';
+
 export default QUnit.module( 'Geometries', () => {
 
 	QUnit.module( 'WireframeGeometry', ( hooks ) => {
 
-		var geometries = undefined; // eslint-disable-line no-unused-vars
+		let geometries = undefined; // eslint-disable-line no-unused-vars
 		hooks.beforeEach( function () {
 
 			geometries = [
@@ -16,9 +19,13 @@ export default QUnit.module( 'Geometries', () => {
 		} );
 
 		// INHERITANCE
-		QUnit.todo( 'Extending', ( assert ) => {
+		QUnit.test( 'Extending', ( assert ) => {
 
-			assert.ok( false, 'everything\'s gonna be alright' );
+			const object = new WireframeGeometry();
+			assert.strictEqual(
+				object instanceof BufferGeometry, true,
+				'WireframeGeometry extends from BufferGeometry'
+			);
 
 		} );
 
@@ -29,6 +36,23 @@ export default QUnit.module( 'Geometries', () => {
 
 		} );
 
+		// PROPERTIES
+		QUnit.test( 'type', ( assert ) => {
+
+			const object = new WireframeGeometry();
+			assert.ok(
+				object.type === 'WireframeGeometry',
+				'WireframeGeometry.type should be WireframeGeometry'
+			);
+
+		} );
+
+		QUnit.todo( 'parameters', ( assert ) => {
+
+			assert.ok( false, 'everything\'s gonna be alright' );
+
+		} );
+
 		// OTHERS
 		QUnit.todo( 'Standard geometry tests', ( assert ) => {