@ohos-ports/stdlib-process-read-stdin 0.0.0-stage → 0.2.3-beta.1

package/node_modules/@stdlib/types/test.ts

@@ -0,0 +1,734 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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.
+*/
+
+/// <reference types="@stdlib/types"/>
+
+import * as array from '@stdlib/types/array';
+import * as blas from '@stdlib/types/blas';
+import * as complex from '@stdlib/types/complex';
+import * as iter from '@stdlib/types/iter';
+import * as ndarray from '@stdlib/types/ndarray';
+import * as obj from '@stdlib/types/object';
+import * as random from '@stdlib/types/random';
+import * as slice from '@stdlib/types/slice';
+
+/**
+* Returns an iterator protocol-compliant object.
+*
+* @returns iterator protocol-compliant object
+*/
+function createIterator1(): iter.Iterator {
+	return {
+		'next': next1
+	};
+}
+
+/**
+* Implements the iterator protocol `next` method.
+*
+* @returns iterator protocol-compliant object
+*/
+function next1(): iter.IteratorResult {
+	return {
+		'value': true,
+		'done': false
+	};
+}
+
+/**
+* Returns an iterator protocol-compliant object.
+*
+* @returns iterator protocol-compliant object
+*/
+function createIterator2(): iter.Iterator {
+	return {
+		'next': next2
+	};
+}
+
+/**
+* Implements the iterator protocol `next` method.
+*
+* @returns iterator protocol-compliant object
+*/
+function next2(): iter.IteratorResult {
+	return {
+		'done': true
+	};
+}
+
+/**
+* Returns an iterable iterator protocol-compliant object.
+*
+* @returns iterable iterator protocol-compliant object
+*/
+function createIterableIterator(): iter.IterableIterator {
+	return {
+		'next': next3,
+		[ Symbol.iterator ]: factory
+	};
+}
+
+/**
+* Implements the iterator protocol `next` method.
+*
+* @returns iterator protocol-compliant object
+*/
+function next3(): iter.IteratorResult {
+	return {
+		'done': true
+	};
+}
+
+/**
+* Returns an iterable iterator protocol-compliant object.
+*
+* @returns iterable iterator protocol-compliant object
+*/
+function factory(): iter.IterableIterator {
+	return createIterableIterator();
+}
+
+/**
+* Returns a boolean array-like object.
+*
+* @returns boolean array-like object
+*/
+function boolArray(): array.BooleanArrayLike {
+	const buf: array.TypedArray = new Uint8Array( 8 );
+	const obj: array.BooleanArrayLike = {
+		'byteLength': 8,
+		'byteOffset': 0,
+		'BYTES_PER_ELEMENT': 1,
+		'length': 8,
+		'get': ( i: number ): boolean => {
+			return Boolean( buf[ i ] );
+		},
+		'set': ( value: boolean, i?: number ) => {
+			i = ( i ) ? i : 0;
+			buf[ i ] = ( buf[ i ] ) ? 1 : 0;
+		}
+	};
+	return obj;
+}
+
+/**
+* Returns a complex number array-like object.
+*
+* @returns complex number array-like object
+*/
+function cmplxArray(): array.ComplexArrayLike {
+	const buf: array.TypedArray = new Float64Array( 8 );
+	const obj: array.ComplexArrayLike = {
+		'byteLength': 64,
+		'byteOffset': 0,
+		'BYTES_PER_ELEMENT': 8,
+		'length': 8,
+		'get': ( i: number ): complex.ComplexLike => {
+			return {
+				're': i * 10,
+				'im': i * 10
+			};
+		},
+		'set': ( value: complex.ComplexLike, i?: number ) => {
+			i = ( i ) ? i : 0;
+			buf[ i ] = value.re;
+			buf[ i + 1 ] = value.im;
+		}
+	};
+	return obj;
+}
+
+/**
+* Returns a 64-bit complex number array.
+*
+* @returns 64-bit complex number array
+*/
+function cmplx64Array(): array.Complex64Array {
+	const buf: array.TypedArray = new Float64Array( 8 );
+	const obj: array.Complex64Array = {
+		'byteLength': 64,
+		'byteOffset': 0,
+		'BYTES_PER_ELEMENT': 8,
+		'length': 8,
+		'get': ( i: number ): complex.Complex64 => {
+			return {
+				're': i * 10,
+				'im': i * 10,
+				'byteLength': 8,
+				'BYTES_PER_ELEMENT': 4
+			};
+		},
+		'set': ( value: complex.Complex64, i?: number ) => {
+			i = ( i ) ? i : 0;
+			buf[ i ] = value.re;
+			buf[ i + 1 ] = value.im;
+		}
+	};
+	return obj;
+}
+
+/**
+* Returns a 128-bit complex number array.
+*
+* @returns 128-bit complex number array
+*/
+function cmplx128Array(): array.Complex128Array {
+	const buf: array.TypedArray = new Float64Array( 16 );
+	const obj: array.Complex128Array = {
+		'byteLength': 128,
+		'byteOffset': 0,
+		'BYTES_PER_ELEMENT': 16,
+		'length': 8,
+		'get': ( i: number ): complex.Complex128 => {
+			return {
+				're': i * 10,
+				'im': i * 10,
+				'byteLength': 16,
+				'BYTES_PER_ELEMENT': 8
+			};
+		},
+		'set': ( value: complex.Complex128, i?: number ) => {
+			i = ( i ) ? i : 0;
+			buf[ i ] = value.re;
+			buf[ i + 1 ] = value.im;
+		}
+	};
+	return obj;
+}
+
+
+// TESTS //
+
+// The compiler should not throw an error when using array type aliases...
+{
+	const v1: array.TypedArray = new Float64Array( 10 );
+	if ( v1[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v2: array.IntegerTypedArray = new Int32Array( 10 );
+	if ( v2[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v3: array.NumericArray = new Float64Array( 10 );
+	if ( v3[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v4: array.ArrayLike<string> = 'beep';
+	if ( v4[ 0 ] !== 'b' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v5: array.ArrayLike<number> = [ 1, 2, 3 ];
+	if ( v5[ 0 ] !== 1 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v6: array.ArrayLike<number> = new Int8Array( 10 );
+	if ( v6[ 0 ] !== 1 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v7: array.ComplexArrayLike = cmplxArray();
+	if ( v7.byteOffset !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v8: array.Complex64Array = cmplx64Array();
+	if ( v8.byteOffset !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v9: array.Complex128Array = cmplx128Array();
+	if ( v9.byteOffset !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v10: array.ComplexTypedArray = cmplx64Array();
+	if ( v10.byteOffset !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v11: array.ArrayOrTypedArray = new Float64Array( 10 );
+	if ( v11[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v12: array.FloatTypedArray = new Float64Array( 10 );
+	if ( v12[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v13: array.RealOrComplexArray = new Float64Array( 10 );
+	if ( v13[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v14: array.RealOrComplexTypedArray = new Float64Array( 10 );
+	if ( v14[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v15buf: array.ArrayLike<number> = new Float64Array( 10 );
+	const v15: array.AccessorArrayLike<number> = {
+		'length': 10,
+		'data': v15buf,
+		'get': ( i: number ): number => v15buf[ i ],
+		'set': ( value: number, i?: number ): void => {
+			v15buf[ i || 0 ] = value;
+			return;
+		}
+	};
+	if ( v15.length !== 10 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v16: array.IntegerTypedArray = new Int32Array( 10 );
+	if ( v16[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v17: array.SignedIntegerTypedArray = new Int32Array( 10 );
+	if ( v17[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v18: array.UnsignedIntegerTypedArray = new Uint32Array( 10 );
+	if ( v18[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v19: array.AnyArray = new Uint32Array( 10 );
+	if ( v19[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v20: array.RealTypedArray = new Uint32Array( 10 );
+	if ( v20[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v21: array.FloatOrComplexTypedArray = new Float64Array( 10 );
+	if ( v21[ 0 ] !== 0.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v22: array.Array1D<number> = [ 1, 2, 3 ];
+	if ( v22.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v23: array.Array2D<number> = [ [ 1, 2, 3 ] ];
+	if ( v23.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v24: array.Array3D<number> = [ [ [ 1, 2, 3 ] ] ];
+	if ( v24.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v25: array.Array4D<number> = [ [ [ [ 1, 2, 3 ] ] ] ];
+	if ( v25.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v26: array.Array5D<number> = [ [ [ [ [ 1, 2, 3 ] ] ] ] ];
+	if ( v26.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v27: array.Array6D<number> = [ [ [ [ [ [ 1, 2, 3 ] ] ] ] ] ];
+	if ( v27.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v28: array.Array7D<number> = [ [ [ [ [ [ [ 1, 2, 3 ] ] ] ] ] ] ];
+	if ( v28.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v29: array.Array8D<number> = [ [ [ [ [ [ [ [ 1, 2, 3 ] ] ] ] ] ] ] ];
+	if ( v29.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v30: array.Array9D<number> = [ [ [ [ [ [ [ [ [ 1, 2, 3 ] ] ] ] ] ] ] ] ];
+	if ( v30.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v31: array.Array10D<number> = [ [ [ [ [ [ [ [ [ [ 1, 2, 3 ] ] ] ] ] ] ] ] ] ];
+	if ( v31.length === 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v32: array.Collection<number> = [ 1, 2, 3 ];
+	if ( v32.length !== 3 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v33: array.BooleanArrayLike = boolArray();
+	if ( v33.byteOffset !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+}
+
+// The compiler should not throw an error when using BLAS types...
+{
+	const v1: blas.Layout = 'row-major';
+	if ( typeof v1 !== 'string' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v2: blas.TransposeOperation = 'transpose';
+	if ( typeof v2 !== 'string' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v3: blas.MatrixTriangle = 'upper';
+	if ( typeof v3 !== 'string' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v4: blas.DiagonalType = 'unit';
+	if ( typeof v4 !== 'string' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v5: blas.OperationSide = 'right';
+	if ( typeof v5 !== 'string' ) {
+		throw new Error( 'something went wrong' );
+	}
+}
+
+// The compiler should not throw an error when using complex number types...
+{
+	const v1: complex.ComplexLike = {
+		're': 1.0,
+		'im': 1.0
+	};
+	if ( v1.re !== 1.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v2: complex.Complex64 = {
+		're': 1.0,
+		'im': 1.0,
+		'byteLength': 8,
+		'BYTES_PER_ELEMENT': 4
+	};
+	if ( v2.re !== 1.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v3: complex.Complex128 = {
+		're': 1.0,
+		'im': 1.0,
+		'byteLength': 16,
+		'BYTES_PER_ELEMENT': 8
+	};
+	if ( v3.re !== 1.0 ) {
+		throw new Error( 'something went wrong' );
+	}
+}
+
+// The compiler should not throw an error when using iterator or iterable types...
+{
+	createIterator1();
+	createIterator2();
+	createIterableIterator();
+}
+
+// The compiler should not throw an error when using ndarray types...
+{
+	const data = [ 1, 2, 3 ];
+	const arr: ndarray.ndarray = {
+		'byteLength': null,
+		'BYTES_PER_ELEMENT': null,
+		'data': data,
+		'dtype': 'generic',
+		'flags': {
+			'ROW_MAJOR_CONTIGUOUS': true,
+			'COLUMN_MAJOR_CONTIGUOUS': false
+		},
+		'length': 3,
+		'ndims': 1,
+		'offset': 0,
+		'order': 'row-major',
+		'shape': [ 3 ],
+		'strides': [ 1 ],
+		'get': ( i: number ): number => {
+			return data[ i ];
+		},
+		'set': ( i: number, v: number ): ndarray.ndarray => {
+			data[ i ] = v;
+			return arr;
+		}
+	};
+	if ( arr.length !== 3 ) {
+		throw new Error( 'something went wrong' );
+	}
+}
+
+// The compiler should not throw an error when using object types...
+{
+	const desc1: obj.DataPropertyDescriptor = {
+		'configurable': true,
+		'enumerable': false,
+		'writable': false,
+		'value': 'beep'
+	};
+	if ( desc1.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc2: obj.DataPropertyDescriptor = {
+		'enumerable': false,
+		'writable': false,
+		'value': 'beep'
+	};
+	if ( desc2.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc3: obj.DataPropertyDescriptor = {
+		'configurable': true,
+		'writable': false,
+		'value': 'beep'
+	};
+	if ( desc3.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc4: obj.DataPropertyDescriptor = {
+		'configurable': true,
+		'enumerable': false,
+		'writable': false
+	};
+	if ( desc4.value ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc5: obj.DataPropertyDescriptor = {
+		'writable': false,
+		'value': 'beep'
+	};
+	if ( desc5.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc6: obj.DataPropertyDescriptor = {
+		'configurable': true,
+		'value': 'beep'
+	};
+	if ( desc6.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc7: obj.DataPropertyDescriptor = {
+		'enumerable': false,
+		'value': 'beep'
+	};
+	if ( desc7.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc8: obj.DataPropertyDescriptor = {
+		'enumerable': false,
+		'writable': false
+	};
+	if ( desc8.value ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc9: obj.AccessorPropertyDescriptor = {
+		'configurable': true,
+		'enumerable': false,
+		'get': (): string => 'beep',
+		'set': () => { throw new Error( 'beep' ); }
+	};
+	if ( desc9.enumerable !== false ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc10: obj.AccessorPropertyDescriptor = {
+		'enumerable': false,
+		'get': (): string => 'beep',
+		'set': () => { throw new Error( 'beep' ); }
+	};
+	if ( desc10.enumerable !== false ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc11: obj.AccessorPropertyDescriptor = {
+		'configurable': true,
+		'get': (): string => 'beep',
+		'set': () => { throw new Error( 'beep' ); }
+	};
+	if ( desc11.enumerable !== false ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc12: obj.AccessorPropertyDescriptor = {
+		'configurable': true,
+		'enumerable': false,
+		'set': () => { throw new Error( 'beep' ); }
+	};
+	if ( desc12.enumerable !== false ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc13: obj.AccessorPropertyDescriptor = {
+		'configurable': true,
+		'enumerable': false,
+		'get': (): string => 'beep'
+	};
+	if ( desc13.enumerable !== false ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc14: obj.AccessorPropertyDescriptor = {
+		'get': (): string => 'beep',
+		'set': () => { throw new Error( 'beep' ); }
+	};
+	if ( desc14.enumerable !== false ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const desc15: obj.PropertyDescriptor = {
+		'configurable': true,
+		'enumerable': false,
+		'writable': false,
+		'value': 'beep'
+	};
+	if ( desc15.value !== 'beep' ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const prop: obj.PropertyName = 'foo';
+	if ( prop !== 'foo' ) {
+		throw new Error( 'something went wrong' );
+	}
+}
+
+// The compiler should not throw an error when using PRNG types...
+{
+	const rand: random.PRNG = (): number => 3.14;
+	if ( rand() !== 3.14 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const s1: random.PRNGSeedMT19937 = 12345;
+	if ( s1 !== 12345 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const s2: random.PRNGSeedMT19937 = new Uint32Array( 10 );
+	if ( s2[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const s3: random.PRNGSeedMINSTD = 12345;
+	if ( s3 !== 12345 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const s4: random.PRNGSeedMINSTD = new Int32Array( 10 );
+	if ( s4[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const s5: random.PRNGStateMT19937 = new Uint32Array( 10 );
+	if ( s5[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const s6: random.PRNGStateMINSTD = new Int32Array( 10 );
+	if ( s6[ 0 ] !== 0 ) {
+		throw new Error( 'something went wrong' );
+	}
+}
+
+// The compiler should not throw an error when using slice types...
+{
+	const v1: slice.Slice = {
+		'start': 0,
+		'stop': 10,
+		'step': 1
+	};
+	if ( v1.start !== v1.start ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v2: slice.Slice = {
+		'start': null,
+		'stop': null,
+		'step': null
+	};
+	if ( v2.start !== v2.start ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v3: slice.Slice = {
+		'start': null,
+		'stop': 10,
+		'step': null
+	};
+	if ( v3.start !== v3.start ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v4: slice.Slice = {
+		'start': 0,
+		'stop': 10,
+		'step': null
+	};
+	if ( v4.start !== v4.start ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v5: slice.Slice = {
+		'start': 0,
+		'stop': null,
+		'step': null
+	};
+	if ( v5.start !== v5.start ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v6: slice.Slice = {
+		'start': 0,
+		'stop': null,
+		'step': 1
+	};
+	if ( v6.start !== v6.start ) {
+		throw new Error( 'something went wrong' );
+	}
+
+	const v7: slice.MultiSlice = {
+		'ndims': 3,
+		'data': [ 1, null, 3 ]
+	};
+	if ( v7.ndims !== v7.ndims ) {
+		throw new Error( 'something went wrong' );
+	}
+}