From 31c8729e18ecd8ca80792f3ab739165b69f28074 Mon Sep 17 00:00:00 2001 From: Gaurav Date: Fri, 12 Sep 2025 00:44:59 +0530 Subject: [PATCH 1/6] test: add tests for slice method in dstructs/named-typed-tuple --- 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 --- --- .../named-typed-tuple/test/test.slice.js | 300 ++++++++++++++++++ 1 file changed, 300 insertions(+) create mode 100644 lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js new file mode 100644 index 000000000000..70f0581defb6 --- /dev/null +++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js @@ -0,0 +1,300 @@ +/** +* @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 hasOwnProp = require( '@stdlib/assert/has-own-property' ); +var isFunction = require( '@stdlib/assert/is-function' ); +var namedtypedtuple = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof namedtypedtuple, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'a tuple has a `slice` method', function test( t ) { + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y' ], { + 'name': 'Point' + }); + p = new Point( [ 10, 20 ] ); + + t.strictEqual( hasOwnProp( p, 'toJSON' ), true, 'returns expected value' ); + t.strictEqual( isFunction( p.toJSON ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the method throws an error if invoked with a `this` context which is not a namedtypedtuple instance', function test( t ) { + var values; + var Point; + var p; + var i; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + + values = [ + '5', + 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 p.slice.call( value ); + }; + } +}); + +tape( 'the method throws an error if provided a first argument which is not an integer', function test( t ) { + var values; + var Point; + var p; + var i; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + + values = [ + '5', + 3.14, + NaN, + true, + false, + null, + void 0, + {}, + [] + ]; + 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 p.slice( value ); + }; + } +}); + +tape( 'the method throws an error if provided a second argument which is not an integer', function test( t ) { + var values; + var Point; + var p; + var i; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + + values = [ + '5', + 3.14, + NaN, + true, + false, + null, + void 0, + {}, + [] + ]; + 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 p.slice( 0, value ); + }; + } +}); + +tape( 'if called without arguments, the method returns a tuple containing the same elements as the original tuple', function test( t ) { + var expected; + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + expected = { + 'x': 10, + 'y': 20, + 'z': 30 + }; + actual = p.slice(); + + t.deepEqual({ + 'x': actual.x, + 'y': actual.y, + 'z': actual.z + }, expected, 'returns expected value' ); + t.notEqual( actual, p, 'returns a new instance' ); + t.end(); +}); + +tape( 'if called with one argument, the method returns a tuple containing elements starting from a specified beginning index (inclusive)', function test( t ) { + var expected; + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); + p = new Point( [ 1, 2, 3, 4 ] ); + expected = { + 'y': 2, + 'z': 3, + 'w': 4 + }; + actual = p.slice( 1 ); + + t.deepEqual({ + 'y': actual.y, + 'z': actual.z, + 'w': actual.w + }, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided two arguments, the method returns a tuple containing elements starting from a specified start index (inclusive) and ending at a specified end index (exclusive)', function test( t ) { + var expected; + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); + p = new Point( [ 1, 2, 3, 4 ] ); + expected = { + 'y': 2, + 'z': 3 + }; + actual = p.slice( 1, 3 ); + + t.deepEqual({ + 'y': actual.y, + 'z': actual.z + }, expected, 'returns expected value' ); + + expected = { + 'y': 2, + 'z': 3, + 'w': 4 + }; + actual = p.slice( 1, 30 ); + + t.deepEqual({ + 'y': actual.y, + 'z': actual.z, + 'w': actual.w + }, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the method resolves negative indices relative to the last element', function test( t ) { + var expected; + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); + p = new Point( [ 1, 2, 3, 4 ] ); + + expected = { + 'y': 2, + 'z': 3 + }; + actual = p.slice( -3, -1 ); + t.deepEqual({ + 'y': actual.y, + 'z': actual.z + }, expected, 'returns expected value' ); + + expected = { + 'x': 1, + 'y': 2 + }; + actual = p.slice( -30, -2 ); + t.deepEqual({ + 'x': actual.x, + 'y': actual.y + }, expected, 'returns expected value' ); + t.end(); +}); + +tape( 'the method returns null if a resolved beginning index exceeds a resolved ending index', function test( t ) { + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); + p = new Point( [ 1, 2, 3, 4 ] ); + actual = p.slice( 2, 0 ); + + t.strictEqual( actual, null, 'returns expected value' ); + t.end(); +}); + +tape( 'the method returns null if a resolved beginning index exceeds the maximum tuple index', function test( t ) { + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 1, 2, 3 ] ); + actual = p.slice( 5 ); + + t.strictEqual( actual, null, 'returns expected value' ); + t.end(); +}); + +tape( 'the method returns null if a resolved ending index is less than or equal to zero', function test( t ) { + var actual; + var Point; + var p; + + Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); + p = new Point( [ 1, 2, 3, 4 ] ); + + actual = p.slice( 2, -8 ); + t.strictEqual( actual, null, 'returns expected value' ); + + actual = p.slice( 1, 0 ); + t.strictEqual( actual, null, 'returns expected value' ); + t.end(); +}); From b595c3700e8c21b6ab1d4a0da26d1a8e1e9b1377 Mon Sep 17 00:00:00 2001 From: Athan Date: Sat, 13 Sep 2025 00:08:05 -0700 Subject: [PATCH 2/6] test: fix method name Signed-off-by: Athan --- .../@stdlib/dstructs/named-typed-tuple/test/test.slice.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js index 70f0581defb6..366fc7f73338 100644 --- a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js +++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js @@ -43,8 +43,8 @@ tape( 'a tuple has a `slice` method', function test( t ) { }); p = new Point( [ 10, 20 ] ); - t.strictEqual( hasOwnProp( p, 'toJSON' ), true, 'returns expected value' ); - t.strictEqual( isFunction( p.toJSON ), true, 'returns expected value' ); + t.strictEqual( hasOwnProp( p, 'slice' ), true, 'returns expected value' ); + t.strictEqual( isFunction( p.slice ), true, 'returns expected value' ); t.end(); }); From 6603d5e41573d601a2deae2f6bff28ba93ea3e55 Mon Sep 17 00:00:00 2001 From: Athan Date: Wed, 17 Sep 2025 14:25:21 -0700 Subject: [PATCH 3/6] test: update tests --- 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 --- --- .../named-typed-tuple/test/test.slice.js | 188 +++++++++++++----- 1 file changed, 137 insertions(+), 51 deletions(-) diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js index 366fc7f73338..ae5f0a264b7a 100644 --- a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js +++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js @@ -48,7 +48,7 @@ tape( 'a tuple has a `slice` method', function test( t ) { t.end(); }); -tape( 'the method throws an error if invoked with a `this` context which is not a namedtypedtuple instance', function test( t ) { +tape( 'the method throws an error if invoked with a `this` context which is not a tuple instance', function test( t ) { var values; var Point; var p; @@ -81,6 +81,72 @@ tape( 'the method throws an error if invoked with a `this` context which is not } }); +tape( 'the method throws an error if invoked with a `this` context which is not a tuple instance (start)', function test( t ) { + var values; + var Point; + var p; + var i; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + + values = [ + '5', + 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 p.slice.call( value, 0 ); + }; + } +}); + +tape( 'the method throws an error if invoked with a `this` context which is not a tuple instance (start, end)', function test( t ) { + var values; + var Point; + var p; + var i; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + + values = [ + '5', + 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 p.slice.call( value, 0, 1 ); + }; + } +}); + tape( 'the method throws an error if provided a first argument which is not an integer', function test( t ) { var values; var Point; @@ -113,6 +179,38 @@ tape( 'the method throws an error if provided a first argument which is not an i } }); +tape( 'the method throws an error if provided a first argument which is not an integer (end)', function test( t ) { + var values; + var Point; + var p; + var i; + + Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); + p = new Point( [ 10, 20, 30 ] ); + + values = [ + '5', + 3.14, + NaN, + true, + false, + null, + void 0, + {}, + [] + ]; + 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 p.slice( value, 1 ); + }; + } +}); + tape( 'the method throws an error if provided a second argument which is not an integer', function test( t ) { var values; var Point; @@ -153,23 +251,26 @@ tape( 'if called without arguments, the method returns a tuple containing the sa Point = namedtypedtuple( [ 'x', 'y', 'z' ] ); p = new Point( [ 10, 20, 30 ] ); + expected = { 'x': 10, 'y': 20, 'z': 30 }; actual = p.slice(); - - t.deepEqual({ + actual = { 'x': actual.x, 'y': actual.y, 'z': actual.z - }, expected, 'returns expected value' ); - t.notEqual( actual, p, 'returns a new instance' ); + }; + + t.notEqual( actual, p, 'returns expected value' ); + t.strictEqual( actual instanceof Point, true, 'returns expected value' ); + t.deepEqual( actual, expected, 'returns expected value' ); t.end(); }); -tape( 'if called with one argument, the method returns a tuple containing elements starting from a specified beginning index (inclusive)', function test( t ) { +tape( 'if provided one argument, the method returns a tuple containing elements starting from a specified index (inclusive)', function test( t ) { var expected; var actual; var Point; @@ -177,18 +278,14 @@ tape( 'if called with one argument, the method returns a tuple containing elemen Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); p = new Point( [ 1, 2, 3, 4 ] ); - expected = { - 'y': 2, - 'z': 3, - 'w': 4 - }; + + expected = [ 2, 3, 4 ]; actual = p.slice( 1 ); - t.deepEqual({ - 'y': actual.y, - 'z': actual.z, - 'w': actual.w - }, expected, 'returns expected value' ); + t.notEqual( actual, p, 'returns expected value' ); + t.strictEqual( actual instanceof Point, true, 'returns expected value' ); + t.deepEqual( actual, expected, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'y', 'z', 'w' ], 'returns expected value' ); t.end(); }); @@ -200,33 +297,26 @@ tape( 'if provided two arguments, the method returns a tuple containing elements Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); p = new Point( [ 1, 2, 3, 4 ] ); - expected = { - 'y': 2, - 'z': 3 - }; + + expected = [ 2, 3 ]; actual = p.slice( 1, 3 ); - t.deepEqual({ - 'y': actual.y, - 'z': actual.z - }, expected, 'returns expected value' ); + t.notEqual( actual, p, 'returns expected value' ); + t.strictEqual( actual instanceof Point, true, 'returns expected value' ); + t.deepEqual( actual, expected, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'y', 'z' ], 'returns expected value' ); - expected = { - 'y': 2, - 'z': 3, - 'w': 4 - }; + expected = [ 2, 3, 4 ]; actual = p.slice( 1, 30 ); - t.deepEqual({ - 'y': actual.y, - 'z': actual.z, - 'w': actual.w - }, expected, 'returns expected value' ); + t.notEqual( actual, p, 'returns expected value' ); + t.strictEqual( actual instanceof Point, true, 'returns expected value' ); + t.deepEqual( actual, expected, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'y', 'z', 'w' ], 'returns expected value' ); t.end(); }); -tape( 'the method resolves negative indices relative to the last element', function test( t ) { +tape( 'the method supports negative indices', function test( t ) { var expected; var actual; var Point; @@ -235,25 +325,21 @@ tape( 'the method resolves negative indices relative to the last element', funct Point = namedtypedtuple( [ 'x', 'y', 'z', 'w' ] ); p = new Point( [ 1, 2, 3, 4 ] ); - expected = { - 'y': 2, - 'z': 3 - }; + expected = [ 2, 3 ]; actual = p.slice( -3, -1 ); - t.deepEqual({ - 'y': actual.y, - 'z': actual.z - }, expected, 'returns expected value' ); - expected = { - 'x': 1, - 'y': 2 - }; + t.notEqual( actual, p, 'returns expected value' ); + t.strictEqual( actual instanceof Point, true, 'returns expected value' ); + t.deepEqual( actual, expected, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'y', 'z' ], 'returns expected value' ); + + expected = [ 2, 3 ]; actual = p.slice( -30, -2 ); - t.deepEqual({ - 'x': actual.x, - 'y': actual.y - }, expected, 'returns expected value' ); + + t.notEqual( actual, p, 'returns expected value' ); + t.strictEqual( actual instanceof Point, true, 'returns expected value' ); + t.deepEqual( actual, expected, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'y', 'z' ], 'returns expected value' ); t.end(); }); From 3b2db58271249f9101737ab963fc0e6233eebd03 Mon Sep 17 00:00:00 2001 From: Athan Date: Wed, 17 Sep 2025 14:27:41 -0700 Subject: [PATCH 4/6] test: update tests --- 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 --- --- .../dstructs/named-typed-tuple/test/test.slice.js | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js index ae5f0a264b7a..483ed795eed6 100644 --- a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js +++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js @@ -265,7 +265,6 @@ tape( 'if called without arguments, the method returns a tuple containing the sa }; t.notEqual( actual, p, 'returns expected value' ); - t.strictEqual( actual instanceof Point, true, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); t.end(); }); @@ -283,7 +282,6 @@ tape( 'if provided one argument, the method returns a tuple containing elements actual = p.slice( 1 ); t.notEqual( actual, p, 'returns expected value' ); - t.strictEqual( actual instanceof Point, true, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); t.deepEqual( actual.fields, [ 'y', 'z', 'w' ], 'returns expected value' ); t.end(); @@ -302,7 +300,6 @@ tape( 'if provided two arguments, the method returns a tuple containing elements actual = p.slice( 1, 3 ); t.notEqual( actual, p, 'returns expected value' ); - t.strictEqual( actual instanceof Point, true, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); t.deepEqual( actual.fields, [ 'y', 'z' ], 'returns expected value' ); @@ -310,7 +307,6 @@ tape( 'if provided two arguments, the method returns a tuple containing elements actual = p.slice( 1, 30 ); t.notEqual( actual, p, 'returns expected value' ); - t.strictEqual( actual instanceof Point, true, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); t.deepEqual( actual.fields, [ 'y', 'z', 'w' ], 'returns expected value' ); t.end(); @@ -329,17 +325,15 @@ tape( 'the method supports negative indices', function test( t ) { actual = p.slice( -3, -1 ); t.notEqual( actual, p, 'returns expected value' ); - t.strictEqual( actual instanceof Point, true, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); t.deepEqual( actual.fields, [ 'y', 'z' ], 'returns expected value' ); - expected = [ 2, 3 ]; + expected = [ 1, 2 ]; actual = p.slice( -30, -2 ); t.notEqual( actual, p, 'returns expected value' ); - t.strictEqual( actual instanceof Point, true, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); - t.deepEqual( actual.fields, [ 'y', 'z' ], 'returns expected value' ); + t.deepEqual( actual.fields, [ 'x', 'y' ], 'returns expected value' ); t.end(); }); From 90e2c7aed501a780db1c2277203ee1b3d7b9a744 Mon Sep 17 00:00:00 2001 From: Athan Date: Wed, 17 Sep 2025 14:29:35 -0700 Subject: [PATCH 5/6] test: add assertion --- 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 --- --- .../@stdlib/dstructs/named-typed-tuple/test/test.slice.js | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js index 483ed795eed6..c80ad85924f7 100644 --- a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js +++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js @@ -266,6 +266,7 @@ tape( 'if called without arguments, the method returns a tuple containing the sa t.notEqual( actual, p, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'x', 'y', 'z' ], 'returns expected value' ); t.end(); }); From fdb5e0359cc642001a5c7c2c2e92fb97d51d5fcd Mon Sep 17 00:00:00 2001 From: Athan Date: Wed, 17 Sep 2025 14:32:08 -0700 Subject: [PATCH 6/6] test: fix broken tests --- 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 --- --- .../@stdlib/dstructs/named-typed-tuple/test/test.slice.js | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js index c80ad85924f7..0fefa6d4925d 100644 --- a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js +++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.slice.js @@ -258,15 +258,16 @@ tape( 'if called without arguments, the method returns a tuple containing the sa 'z': 30 }; actual = p.slice(); + + t.notEqual( actual, p, 'returns expected value' ); + t.deepEqual( actual.fields, [ 'x', 'y', 'z' ], 'returns expected value' ); + actual = { 'x': actual.x, 'y': actual.y, 'z': actual.z }; - - t.notEqual( actual, p, 'returns expected value' ); t.deepEqual( actual, expected, 'returns expected value' ); - t.deepEqual( actual.fields, [ 'x', 'y', 'z' ], 'returns expected value' ); t.end(); });