dtypes/test/test.js

/**
* @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 dtypes = require( './../lib' );


// TESTS //

tape( 'main export is a function', function test( t ) {
	t.ok( true, __filename );
	t.strictEqual( typeof dtypes, 'function', 'main export is a function' );
	t.end();
});

tape( 'the function returns a list of array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'complex64',
		'complex128',
		'float32',
		'float64',
		'generic',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes();

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of array data types (all)', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'complex64',
		'complex128',
		'float32',
		'float64',
		'generic',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'all' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of array data types (all, including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'complex64',
		'complex128',
		'float32',
		'float64',
		'generic',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'all_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of array data types (typed)', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'complex64',
		'complex128',
		'float32',
		'float64',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'typed' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of array data types (typed, including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'complex64',
		'complex128',
		'float32',
		'float64',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c',
		'generic'
	];
	actual = dtypes( 'typed_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of floating-point array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'complex64',
		'complex128',
		'float32',
		'float64'
	];
	actual = dtypes( 'floating_point' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of floating-point array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'complex64',
		'complex128',
		'float32',
		'float64',
		'generic'
	];
	actual = dtypes( 'floating_point_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of real-valued floating-point array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'float32',
		'float64'
	];
	actual = dtypes( 'real_floating_point' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of real-valued floating-point array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'float32',
		'float64',
		'generic'
	];
	actual = dtypes( 'real_floating_point_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of complex-valued floating-point array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'complex64',
		'complex128'
	];
	actual = dtypes( 'complex_floating_point' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of complex-valued floating-point array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'complex64',
		'complex128',
		'generic'
	];
	actual = dtypes( 'complex_floating_point_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of boolean array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool'
	];
	actual = dtypes( 'boolean' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of boolean array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'generic'
	];
	actual = dtypes( 'boolean_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of integer array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'integer' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of integer array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c',
		'generic'
	];
	actual = dtypes( 'integer_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of signed integer array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int16',
		'int32',
		'int8'
	];
	actual = dtypes( 'signed_integer' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of signed integer array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int16',
		'int32',
		'int8',
		'generic'
	];
	actual = dtypes( 'signed_integer_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of unsigned integer array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'unsigned_integer' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of unsigned integer array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'uint16',
		'uint32',
		'uint8',
		'uint8c',
		'generic'
	];
	actual = dtypes( 'unsigned_integer_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of real-valued array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'float32',
		'float64',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'real' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of real-valued array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'float32',
		'float64',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c',
		'generic'
	];
	actual = dtypes( 'real_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of numeric array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'complex64',
		'complex128',
		'float32',
		'float64',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c'
	];
	actual = dtypes( 'numeric' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of numeric array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'complex64',
		'complex128',
		'float32',
		'float64',
		'int16',
		'int32',
		'int8',
		'uint16',
		'uint32',
		'uint8',
		'uint8c',
		'generic'
	];
	actual = dtypes( 'numeric_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of integer index array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int32'
	];
	actual = dtypes( 'integer_index' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of integer index array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int32',
		'generic'
	];
	actual = dtypes( 'integer_index_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of boolean index array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool'
	];
	actual = dtypes( 'boolean_index' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of boolean index array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'bool',
		'generic'
	];
	actual = dtypes( 'boolean_index_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of mask index array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'uint8'
	];
	actual = dtypes( 'mask_index' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of mask index array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'uint8',
		'generic'
	];
	actual = dtypes( 'mask_index_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of typed index array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int32',
		'uint8',
		'bool'
	];
	actual = dtypes( 'typed_index' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of typed index array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int32',
		'uint8',
		'bool',
		'generic'
	];
	actual = dtypes( 'typed_index_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of index array data types', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int32',
		'uint8',
		'bool',
		'generic'
	];
	actual = dtypes( 'index' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function supports returning a list of index array data types (including "generic")', function test( t ) {
	var expected;
	var actual;

	expected = [
		'int32',
		'uint8',
		'bool',
		'generic'
	];
	actual = dtypes( 'index_and_generic' );

	t.deepEqual( actual, expected, 'returns expected value' );
	t.end();
});

tape( 'the function returns an empty array if provided an unrecognized data type kind', function test( t ) {
	t.deepEqual( dtypes( 'beep' ), [], 'returns expected value' );
	t.deepEqual( dtypes( 'beep_and_generic' ), [], 'returns expected value' );
	t.deepEqual( dtypes( 'generic' ), [], 'returns expected value' );
	t.deepEqual( dtypes( '_and_generic' ), [], 'returns expected value' );
	t.deepEqual( dtypes( '' ), [], 'returns expected value' );
	t.end();
});