feat(array/fixed-endian-float64): add comprehensive unit tests

- Add tests for constructor functionality
- Add tests for endianness validation
- Add tests for various initialization methods
- Resolves TODO in test.js

Author: Sameer-choudhary-git

lib/node_modules/@stdlib/array/fixed-endian-float64/test/test.js

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -21,15 +21,119 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var ctor = require( './../lib' );
+var Float64ArrayFE = require( './../lib' );
 
 
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof ctor, 'function', 'main export is a function' );
+	t.strictEqual( typeof Float64ArrayFE, 'function', 'main export is a function' );
 	t.end();
 });
 
-// TODO: add tests
+tape( 'the function is a constructor', function test( t ) {
+	var arr = new Float64ArrayFE( 'little-endian' );
+	t.strictEqual( arr instanceof Float64ArrayFE, true, 'returns an instance' );
+	t.end();
+});
+
+tape( 'the constructor throws an error if not provided a valid endianness as the first argument', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		'foo',
+		'bar',
+		'beep',
+		'boop',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			return new Float64ArrayFE( value );
+		};
+	}
+});
+
+tape( 'the constructor returns an instance with a `length` property', function test( t ) {
+	var arr = new Float64ArrayFE( 'little-endian', 10 );
+	t.strictEqual( arr.length, 10, 'has length property' );
+	t.end();
+});
+
+tape( 'the constructor supports creating a zero-length array', function test( t ) {
+	var arr = new Float64ArrayFE( 'big-endian', 0 );
+	t.strictEqual( arr.length, 0, 'has zero length' );
+	t.end();
+});
+
+tape( 'the constructor supports little-endian byte order', function test( t ) {
+	var arr = new Float64ArrayFE( 'little-endian', [ 1.0, 2.0, 3.0 ] );
+	t.strictEqual( arr.get( 0 ), 1.0, 'returns expected value' );
+	t.strictEqual( arr.get( 1 ), 2.0, 'returns expected value' );
+	t.strictEqual( arr.get( 2 ), 3.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the constructor supports big-endian byte order', function test( t ) {
+	var arr = new Float64ArrayFE( 'big-endian', [ 1.0, 2.0, 3.0 ] );
+	t.strictEqual( arr.get( 0 ), 1.0, 'returns expected value' );
+	t.strictEqual( arr.get( 1 ), 2.0, 'returns expected value' );
+	t.strictEqual( arr.get( 2 ), 3.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the constructor supports creating an array from an array-like object', function test( t ) {
+	var arr = new Float64ArrayFE( 'little-endian', [ 1.0, 2.0, 3.0 ] );
+	t.strictEqual( arr.length, 3, 'has expected length' );
+	t.strictEqual( arr.get( 0 ), 1.0, 'returns expected value' );
+	t.strictEqual( arr.get( 1 ), 2.0, 'returns expected value' );
+	t.strictEqual( arr.get( 2 ), 3.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the constructor supports creating an array from a typed array', function test( t ) {
+	var buf = new Float64Array( [ 1.0, 2.0, 3.0 ] );
+	var arr = new Float64ArrayFE( 'big-endian', buf );
+	t.strictEqual( arr.length, 3, 'has expected length' );
+	t.strictEqual( arr.get( 0 ), 1.0, 'returns expected value' );
+	t.strictEqual( arr.get( 1 ), 2.0, 'returns expected value' );
+	t.strictEqual( arr.get( 2 ), 3.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the constructor supports creating an array from an ArrayBuffer', function test( t ) {
+	var buf = new ArrayBuffer( 24 ); // 3 * 8 bytes
+	var arr = new Float64ArrayFE( 'little-endian', buf );
+	t.strictEqual( arr.length, 3, 'has expected length' );
+	t.end();
+});
+
+tape( 'the constructor supports creating an array from an ArrayBuffer with a byte offset', function test( t ) {
+	var buf = new ArrayBuffer( 32 );
+	var arr = new Float64ArrayFE( 'big-endian', buf, 8 );
+	t.strictEqual( arr.length, 3, 'has expected length' );
+	t.end();
+});
+
+tape( 'the constructor supports creating an array from an ArrayBuffer with a byte offset and length', function test( t ) {
+	var buf = new ArrayBuffer( 32 );
+	var arr = new Float64ArrayFE( 'little-endian', buf, 8, 2 );
+	t.strictEqual( arr.length, 2, 'has expected length' );
+	t.end();
+});