feat: add boolean array tests

lib/node_modules/@stdlib/array/to-fancy/lib/get_elements.js

@@ -21,8 +21,8 @@
 // MODULES //
 
 var take = require( '@stdlib/array/take' );
-var mskfilter = require( '@stdlib/array/base/mskfilter' );
-var mskreject = require( '@stdlib/array/base/mskreject' );
+var mskfilter = require( '@stdlib/array/mskfilter' );
+var mskreject = require( '@stdlib/array/mskreject' );
 var format = require( '@stdlib/string/format' );
 var prop2array = require( './prop2array.js' );
 

lib/node_modules/@stdlib/array/to-fancy/test/test.get.boolean_array.js

@@ -0,0 +1,252 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var hasProxySupport = require( '@stdlib/assert/has-proxy-support' );
+var Int32Array = require( '@stdlib/array/int32' );
+var array2fancy = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': !hasProxySupport()
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof array2fancy, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function returns an array-like object supporting boolean array indexing (generic)', opts, function test( t ) {
+	var expected;
+	var actual;
+	var idx;
+	var x;
+	var y;
+
+	x = [ 1, 2, 3, 4 ];
+	y = array2fancy( x );
+
+	idx = array2fancy.idx( [ true, true, true, true ] );
+	expected = [ 1, 2, 3, 4 ];
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ false, false, false, false ] );
+	expected = [];
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ true, true, false, false ] );
+	expected = [ 1, 2 ];
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ false, true, true, false ] );
+	expected = [ 2, 3 ];
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ true, false, true, false ] );
+	expected = [ 1, 3 ];
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns an array-like object boolean array indexing (typed)', opts, function test( t ) {
+	var expected;
+	var actual;
+	var idx;
+	var x;
+	var y;
+
+	x = new Int32Array( [ 1, 2, 3, 4 ] );
+	y = array2fancy( x );
+
+	idx = array2fancy.idx( [ true, true, true, true ] );
+	expected = new Int32Array( [ 1, 2, 3, 4 ] );
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ false, false, false, false ] );
+	expected = new Int32Array( [] );
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ true, true, false, false ] );
+	expected = new Int32Array( [ 1, 2 ] );
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ false, true, true, false ] );
+	expected = new Int32Array( [ 2, 3 ] );
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	idx = array2fancy.idx( [ true, false, true, false ] );
+	expected = new Int32Array( [ 1, 3 ] );
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns an array-like object boolean array indexing which can themselves support boolean arrays (generic)', opts, function test( t ) {
+	var expected;
+	var actual;
+	var idx;
+	var x;
+	var y;
+	var z;
+
+	x = [ 1, 2, 3, 4 ];
+	y = array2fancy( x );
+
+	idx = array2fancy.idx( [ true, true, true, true ] );
+	expected = [ 1, 2, 3, 4 ];
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	z = actual;
+
+	idx = array2fancy.idx( [ true, false, true, false ] );
+	expected = [ 1, 3 ];
+	actual = z[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.notEqual( actual, z, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	z = actual;
+
+	idx = array2fancy.idx( [ false, true ] );
+	expected = [ 3 ];
+	actual = z[ idx ];
+
+	t.strictEqual( actual instanceof Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.notEqual( actual, z, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns an array-like object boolean array indexing which can themselves support boolean arrays (typed)', opts, function test( t ) {
+	var expected;
+	var actual;
+	var idx;
+	var x;
+	var y;
+	var z;
+
+	x = new Int32Array( [ 1, 2, 3, 4 ] );
+	y = array2fancy( x );
+
+	idx = array2fancy.idx( [ true, true, true, true ] );
+	expected = new Int32Array( [ 1, 2, 3, 4 ] );
+	actual = y[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	z = actual;
+
+	idx = array2fancy.idx( [ true, false, true, false ] );
+	expected = new Int32Array( [ 1, 3 ] );
+	actual = z[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.notEqual( actual, z, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	z = actual;
+
+	idx = array2fancy.idx( [ false, true ] );
+	expected = new Int32Array( [ 3 ] );
+	actual = z[ idx ];
+
+	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
+	t.notEqual( actual, x, 'different reference' );
+	t.notEqual( actual, y, 'different reference' );
+	t.notEqual( actual, z, 'different reference' );
+	t.deepEqual( actual, expected, 'returns expected value' );
+
+	t.end();
+});

lib/node_modules/@stdlib/array/to-fancy/test/test.get.integer_array.js

@@ -155,7 +155,7 @@ tape( 'the function returns an array-like object integer array indexing (typed)'
 	t.deepEqual( actual, expected, 'returns expected value' );
 
 	idx = array2fancy.idx( [] );
-	expected = [];
+	expected = new Int32Array( [] );
 	actual = y[ idx ];
 
 	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );
@@ -164,7 +164,7 @@ tape( 'the function returns an array-like object integer array indexing (typed)'
 	t.deepEqual( actual, expected, 'returns expected value' );
 
 	idx = array2fancy.idx( new Int32Array( [] ) );
-	expected = [];
+	expected = new Int32Array( [] );
 	actual = y[ idx ];
 
 	t.strictEqual( actual instanceof Int32Array, true, 'returns expected value' );