test: add tests for package csignumf-assign

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: Deepak91168

lib/node_modules/@stdlib/math/base/special/csignumf/test/test.assign.js

@@ -0,0 +1,115 @@
+/**
+* @license Apache-2.0
+*
+* 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.
+* 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 Float32Array = require( '@stdlib/array/float32' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var isNegativeZerof = require( '@stdlib/math/base/assert/is-negative-zerof' );
+var isPositiveZerof = require( '@stdlib/math/base/assert/is-positive-zerof' );
+var absf = require( '@stdlib/math/base/special/absf' );
+var EPS = require( '@stdlib/constants/float32/eps' );
+var csignumf = require( './../lib' );
+
+
+// FIXTURES //
+
+var data = require( './fixtures/julia/data.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof csignumf.assign, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function evaluates the signum function and writes to output array', function test( t ) {
+	var expectedRe = data.expected_re;
+	var expectedIm = data.expected_im;
+	var returned;
+	var output;
+	var delta;
+	var tol;
+	var re = data.re;
+	var im = data.im;
+	var i;
+
+	for ( i = 0; i < re.length; i++ ) {
+		// Skip NaN cases for separate dedicated tests:
+		if ( isnanf( expectedRe[i] ) || isnanf( expectedIm[i] ) ) {
+			continue;
+		}
+
+		output = new Float32Array( 2 );
+		returned = csignumf.assign( re[i], im[i], output, 1, 0 );
+
+		t.ok( returned instanceof Float32Array, 'returns a Float32Array' );
+		t.strictEqual( returned, output, 'returns same output array reference' );
+
+		if ( output[ 0 ] === expectedRe[ i ] && output[ 1 ] === expectedIm[ i ] ) {
+			t.strictEqual( output[ 0 ], expectedRe[ i ], 're: ' + re[ i ] + '. Expected: ' + expectedRe[ i ] );
+			t.strictEqual( output[ 1 ], expectedIm[ i ], 'im: ' + im[ i ] + '. Expected: ' + expectedIm[ i ] );
+		} else {
+			delta = absf( output[ 0 ] - expectedRe[ i ] );
+			tol = EPS * absf( expectedRe[ i ] );
+			t.ok( delta <= tol, 'within tolerance. re: ' + re[ i ] + '. Expected: ' + expectedRe[ i ] + '. Actual: ' + output[ 0 ] + '. Δ: ' + delta + '. tol: ' + tol + '.' );
+
+			delta = absf( output[ 1 ] - expectedIm[ i ] );
+			tol = EPS * absf( expectedIm[ i ] );
+			t.ok( delta <= tol, 'within tolerance. im: ' + im[ i ] + '. Expected: ' + expectedIm[ i ] + '. Actual: ' + output[ 1 ] + '. Δ: ' + delta + '. tol: ' + tol + '.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns NaNs if either input is NaN', function test( t ) {
+	var returned;
+	var outNaN;
+
+	outNaN = new Float32Array( 2 );
+	returned = csignumf.assign( NaN, NaN, outNaN, 1, 0 );
+
+	t.ok( returned instanceof Float32Array, 'returns a Float32Array' );
+	t.strictEqual( returned, outNaN, 'returns same output array reference' );
+	t.strictEqual( isnanf( outNaN[ 0 ] ), true, 'real is NaN' );
+	t.strictEqual( isnanf( outNaN[ 1 ] ), true, 'imag is NaN' );
+	t.end();
+});
+
+tape( 'the function returns +0 if input is +0 +0i', function test( t ) {
+	var outPosZero = new Float32Array( 2 );
+	csignumf.assign( +0.0, +0.0, outPosZero, 1, 0 );
+
+	t.strictEqual( isPositiveZerof( outPosZero[ 0 ] ), true, 'real is +0' );
+	t.strictEqual( isPositiveZerof( outPosZero[ 1 ] ), true, 'imag is +0' );
+	t.end();
+});
+
+tape( 'the function returns -0 if input is -0 -0i', function test( t ) {
+	var outNegZero = new Float32Array( 2 );
+	csignumf.assign( -0.0, -0.0, outNegZero, 1, 0 );
+
+	t.strictEqual( isNegativeZerof( outNegZero[ 0 ] ), true, 'real is -0' );
+	t.strictEqual( isNegativeZerof( outNegZero[ 1 ] ), true, 'imag is -0' );
+	t.end();
+});