From 47c87175bbb49ee55f5f8d38f882b0380ac03d92 Mon Sep 17 00:00:00 2001 From: dr-irina Date: Thu, 28 Aug 2025 09:18:15 +0000 Subject: [PATCH] TA reduce tests Issue: https://gitee.com/openharmony/arkcompiler_runtime_core/issues/ICUKXQ Testing: tests were added Signed-off-by: dr-irina --- .../escompat/Float32ArrayReduceTest.ets | 307 ++++++++++++++++++ .../escompat/Float64ArrayFromTest.ets | 24 +- .../escompat/Float64ArrayReduceTest.ets | 306 +++++++++++++++++ .../escompat/Int16ArrayReduceTest.ets | 296 +++++++++++++++++ .../escompat/Int32ArrayReduceTest.ets | 296 +++++++++++++++++ .../escompat/Int8ArrayReduceTest.ets | 278 ++++++++++++++++ .../escompat/Uint16ArrayReduceTest.ets | 294 +++++++++++++++++ .../escompat/Uint32ArrayReduceTest.ets | 296 +++++++++++++++++ .../escompat/Uint8ArrayReduceTest.ets | 296 +++++++++++++++++ .../escompat/Uint8ClampedArrayReduceTest.ets | 296 +++++++++++++++++ 10 files changed, 2677 insertions(+), 12 deletions(-) create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Float32ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Int16ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Int32ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Int8ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Uint16ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Uint32ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ArrayReduceTest.ets create mode 100644 static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ClampedArrayReduceTest.ets diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Float32ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Float32ArrayReduceTest.ets new file mode 100644 index 0000000000..32bdeaa311 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Float32ArrayReduceTest.ets @@ -0,0 +1,307 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Float32ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + // float-specific: accumulation precision + suite.addTest("reduce – float precision sum with epsilon", test_reduce_float_precision); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Float32Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Float32Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Float32Array([5, -2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + // No initialValue => 3 calls for length=4, starting with first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Float32Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Float32Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Float32Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Float32Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Float32Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Float32Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Float32Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Float32Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Float32Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Float32Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Float32Array): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Float32Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Float32Array([5, -2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Float32Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Float32Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Float32Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Float32Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Float32Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Float32Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Float32Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Float32Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Float32Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Float32Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Float32Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* float-specific: precision behavior (use epsilon) */ + +function test_reduce_float_precision(): void { + const arr = new Float32Array([0.1, 0.2, 0.3]); + const sum = arr.reduce((p: number, c: number) => p + c, 0); + arktest.assertDoubleEQ(sum, 0.6, 1e-6); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayFromTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayFromTest.ets index 5886241b96..4ffd509907 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayFromTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayFromTest.ets @@ -22,10 +22,10 @@ function testArrayLikeNumber(): void { const ta = Float64Array.from(arr); arktest.assertEQ(ta.length, 4); const epsilon = 1e-12; - arktest.assertTrue(Math.abs(ta.$_get(0).toDouble() - 1.23456789012345) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(1).toDouble() + 2.34567890123456) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(2).toDouble() - 3.45678901234567) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(3).toDouble() + 4.56789012345678) < epsilon); + arktest.assertDoubleEQ(ta.$_get(0).toDouble(), 1.23456789012345, epsilon); + arktest.assertDoubleEQ(ta.$_get(1).toDouble(), -2.34567890123456, epsilon); + arktest.assertDoubleEQ(ta.$_get(2).toDouble(), 3.45678901234567, epsilon); + arktest.assertDoubleEQ(ta.$_get(3).toDouble(), -4.56789012345678, epsilon); } function testIterableNumberWithoutMap(): void { @@ -33,9 +33,9 @@ function testIterableNumberWithoutMap(): void { const ta = Float64Array.from(iterable); arktest.assertEQ(ta.length, 3); const epsilon = 1e-12; - arktest.assertTrue(Math.abs(ta.$_get(0).toDouble() - 0.125) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(1).toDouble() + 0.875) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(2).toDouble() - 2.5) < epsilon); + arktest.assertDoubleEQ(ta.$_get(0).toDouble(), 0.125, epsilon); + arktest.assertDoubleEQ(ta.$_get(1).toDouble(), -0.875, epsilon); + arktest.assertDoubleEQ(ta.$_get(2).toDouble(), 2.5, epsilon); } function testIterableNumberWithMap(): void { @@ -43,9 +43,9 @@ function testIterableNumberWithMap(): void { const ta = Float64Array.from(arr, (v: number, idx: number): number => v + idx * 0.5); arktest.assertEQ(ta.length, 3); const epsilon = 1e-12; - arktest.assertTrue(Math.abs(ta.$_get(0).toDouble() - 1.0) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(1).toDouble() - 2.5) < epsilon); - arktest.assertTrue(Math.abs(ta.$_get(2).toDouble() - 4.0) < epsilon); + arktest.assertDoubleEQ(ta.$_get(0).toDouble(), 1.0, epsilon); + arktest.assertDoubleEQ(ta.$_get(1).toDouble(), 2.5, epsilon); + arktest.assertDoubleEQ(ta.$_get(2).toDouble(), 4.0, epsilon); } function testMapfnInfinity(): void { @@ -79,7 +79,7 @@ function testDynamicReallocation(): void { const epsilon = 1e-12; let idx = 0; for (const v of iterable) { - arktest.assertTrue(Math.abs(ta.$_get(idx).toDouble() - v) < epsilon); + arktest.assertDoubleEQ(ta.$_get(idx).toDouble(), v, epsilon); idx++; } } @@ -89,7 +89,7 @@ function testBufferIndependence(): void { const ta = Float64Array.from(src); src[0] = 9.999; const epsilon = 1e-12; - arktest.assertTrue(Math.abs(ta.$_get(0).toDouble() - 0.123) < epsilon); + arktest.assertDoubleEQ(ta.$_get(0).toDouble(), 0.123, epsilon); } function main(): int { diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayReduceTest.ets new file mode 100644 index 0000000000..12f69a90ce --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Float64ArrayReduceTest.ets @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Float64ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + // float-specific: accumulation precision + suite.addTest("reduce – float precision sum with epsilon", test_reduce_float_precision); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Float64Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Float64Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Float64Array([5, -2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Float64Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Float64Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Float64Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Float64Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Float64Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Float64Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Float64Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Float64Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Float64Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Float64Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Float64Array): number => prev - cur); + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Float64Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Float64Array([5, -2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Float64Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Float64Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Float64Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Float64Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Float64Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Float64Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Float64Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Float64Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Float64Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Float64Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Float64Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* float-specific: precision behavior (use tight epsilon) */ + +function test_reduce_float_precision(): void { + const arr = new Float64Array([0.1, 0.2, 0.3]); + const sum = arr.reduce((p: number, c: number) => p + c, 0); + const eps = 1e-12; + arktest.assertTrue(Math.abs(sum - 0.6) < eps); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Int16ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Int16ArrayReduceTest.ets new file mode 100644 index 0000000000..b0ecff2b51 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Int16ArrayReduceTest.ets @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Int16ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int16Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Int16Array([5, -2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + // No initialValue => 3 calls for length=4, starting with first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Int16Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int16Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Int16Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Int16Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Int16Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Int16Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int16Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Int16Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Int16Array): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Int16Array([5, -2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Int16Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Int16Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Int16Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Int16Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Int16Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Int16Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Int16Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Int32ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Int32ArrayReduceTest.ets new file mode 100644 index 0000000000..b0ecff2b51 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Int32ArrayReduceTest.ets @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Int16ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int16Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Int16Array([5, -2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + // No initialValue => 3 calls for length=4, starting with first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Int16Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int16Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Int16Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Int16Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Int16Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Int16Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int16Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Int16Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Int16Array): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Int16Array([5, -2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Int16Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Int16Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Int16Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Int16Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Int16Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Int16Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Int16Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Int16Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Int16Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Int16Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Int8ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Int8ArrayReduceTest.ets new file mode 100644 index 0000000000..d64ba4c787 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Int8ArrayReduceTest.ets @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +function main(): int { + const suite = new arktest.ArkTestsuite("Int8ArrayReduce"); + + suite.addTest("reduce number/no init full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init 0 args", test_reduce_number_noInit_zeroArgs); + + suite.addTest("reduce number/with init full args", test_reduce_number_withInit_fullArgs); + + suite.addTest("reduce generic/with init full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init 0 args", test_reduce_generic_number_zeroArgs); + + suite.addTest("reduce index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce throws on empty without init", test_reduce_throws_on_empty); + + suite.addTest("reduceRight number/no init full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init 0 args", test_reduceRight_number_noInit_zeroArgs); + + suite.addTest("reduceRight number/with init full args", test_reduceRight_number_withInit_fullArgs); + + suite.addTest("reduceRight generic/with init full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init 0 args", test_reduceRight_generic_number_zeroArgs); + + suite.addTest("reduceRight order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int8Array): number => { + return prev + cur; + }); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Int8Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Int8Array([5, -2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); // increments per step + // No initialValue => 3 calls for length=4, starting from first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Int8Array([9, 8, 7]); + const res = arr.reduce((): number => 100); + // No initialValue => 2 calls -> both return 100 -> final 100 + arktest.assertEQ(res, 100); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int8Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Int8Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Int8Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +class Acc { sum: number = 0; count: number = 0}; +function test_reduce_generic_object_threeArgs(): void { + const arr = new Int8Array([2, 4, 6]); + const acc = arr.reduce((prev: Acc, cur: number, idx: number): Acc => { + prev.sum += cur; + prev.count += 1; + return prev; + }, { sum: 0, count: 0 }); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Int8Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Int8Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); // first call returns 7, then stays 7 +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Int8Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Int8Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + // no initialValue => indexes visited: 1,2 + arktest.assertEQ(visited.length, 2); + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Int8Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Int8Array): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Int8Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Int8Array([5, -2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + // length 4 => 3 calls + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Int8Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Int8Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Int8Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Int8Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Int8Array): string => prev + `(${cur}<${idx})`, + "R" + ); + // Right to left: idx 2,1,0 + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +class AccR { prod: number; steps: number }; +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Int8Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccR, cur: number, idx: number): AccR => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, { prod: 1, steps: 0 }); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Int8Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Int8Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Int8Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Int8Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Int8Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint16ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint16ArrayReduceTest.ets new file mode 100644 index 0000000000..93f49b4785 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint16ArrayReduceTest.ets @@ -0,0 +1,294 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Uint16ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint16Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Uint16Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Uint16Array([5, 2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Uint16Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint16Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Uint16Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Uint16Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Uint16Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Uint16Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Uint16Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Uint16Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint16Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Uint16Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint16Array): number => prev - cur); + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Uint16Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Uint16Array([5, 2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Uint16Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Uint16Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint16Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Uint16Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Uint16Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Uint16Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Uint16Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Uint16Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Uint16Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Uint16Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Uint16Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint32ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint32ArrayReduceTest.ets new file mode 100644 index 0000000000..ae29526978 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint32ArrayReduceTest.ets @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Uint32ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint32Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Uint32Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Uint32Array([5, 2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + // No initialValue => 3 calls for length=4, starting with first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Uint32Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint32Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Uint32Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Uint32Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Uint32Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Uint32Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Uint32Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Uint32Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint32Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Uint32Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint32Array): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Uint32Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Uint32Array([5, 2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Uint32Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Uint32Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint32Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Uint32Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Uint32Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Uint32Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Uint32Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Uint32Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Uint32Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Uint32Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Uint32Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ArrayReduceTest.ets new file mode 100644 index 0000000000..a72f84a6b4 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ArrayReduceTest.ets @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Uint8ArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint8Array): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Uint8Array([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Uint8Array([5, 2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + // No initialValue => 3 calls for length=4, starting with first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Uint8Array([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint8Array): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Uint8Array([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Uint8Array): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Uint8Array([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Uint8Array([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Uint8Array([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Uint8Array([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint8Array): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Uint8Array(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint8Array): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Uint8Array([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Uint8Array([5, 2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Uint8Array([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Uint8Array([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint8Array): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Uint8Array([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Uint8Array): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Uint8Array([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Uint8Array([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Uint8Array([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Uint8Array([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Uint8Array([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Uint8Array(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ClampedArrayReduceTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ClampedArrayReduceTest.ets new file mode 100644 index 0000000000..b00c0d4538 --- /dev/null +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/Uint8ClampedArrayReduceTest.ets @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * 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. + */ + +class AccSumCount { + sum: number; + count: number; + constructor(sum: number, count: number) { + this.sum = sum; + this.count = count; + } +} + +class AccProdSteps { + prod: number; + steps: number; + constructor(prod: number, steps: number) { + this.prod = prod; + this.steps = steps; + } +} + +function main(): int { + const suite = new arktest.ArkTestsuite("Uint8ClampedArrayReduce"); + + // reduce – number, no initialValue, varying callback arity + suite.addTest("reduce number/no init – full args", test_reduce_number_noInit_fullArgs); + suite.addTest("reduce number/no init – 3 args", test_reduce_number_noInit_threeArgs); + suite.addTest("reduce number/no init – 2 args", test_reduce_number_noInit_twoArgs); + suite.addTest("reduce number/no init – 1 arg", test_reduce_number_noInit_oneArg); + suite.addTest("reduce number/no init – 0 args", test_reduce_number_noInit_zeroArgs); + + // reduce – number with initialValue + suite.addTest("reduce number/with init – full args", test_reduce_number_withInit_fullArgs); + + // reduce – generic with initialValue, varying arity + suite.addTest("reduce generic/with init – full args", test_reduce_generic_string_fullArgs); + suite.addTest("reduce generic/with init – 3 args", test_reduce_generic_object_threeArgs); + suite.addTest("reduce generic/with init – 2 args", test_reduce_generic_boolean_twoArgs); + suite.addTest("reduce generic/with init – 1 arg", test_reduce_generic_number_oneArg); + suite.addTest("reduce generic/with init – 0 args", test_reduce_generic_number_zeroArgs); + + // reduce – index/array params + exception cases + suite.addTest("reduce – index and array params", test_reduce_index_and_array_params); + suite.addTest("reduce – throws on empty without init", test_reduce_throws_on_empty); + + // reduceRight – number, no initialValue, varying callback arity + suite.addTest("reduceRight number/no init – full args", test_reduceRight_number_noInit_fullArgs); + suite.addTest("reduceRight number/no init – 3 args", test_reduceRight_number_noInit_threeArgs); + suite.addTest("reduceRight number/no init – 2 args", test_reduceRight_number_noInit_twoArgs); + suite.addTest("reduceRight number/no init – 1 arg", test_reduceRight_number_noInit_oneArg); + suite.addTest("reduceRight number/no init – 0 args", test_reduceRight_number_noInit_zeroArgs); + + // reduceRight – number with initialValue + suite.addTest("reduceRight number/with init – full args", test_reduceRight_number_withInit_fullArgs); + + // reduceRight – generic with initialValue, varying arity + suite.addTest("reduceRight generic/with init – full args", test_reduceRight_generic_string_fullArgs); + suite.addTest("reduceRight generic/with init – 3 args", test_reduceRight_generic_object_threeArgs); + suite.addTest("reduceRight generic/with init – 2 args", test_reduceRight_generic_boolean_twoArgs); + suite.addTest("reduceRight generic/with init – 1 arg", test_reduceRight_generic_number_oneArg); + suite.addTest("reduceRight generic/with init – 0 args", test_reduceRight_generic_number_zeroArgs); + + // reduceRight – order + exception + suite.addTest("reduceRight – order verification", test_reduceRight_order_verification); + suite.addTest("reduceRight – throws on empty without init", test_reduceRight_throws_on_empty); + + return suite.run(); +} + +/* reduce – number, no initialValue, varying callback arity */ + +function test_reduce_number_noInit_fullArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint8ClampedArray): number => prev + cur); + arktest.assertEQ(sum, 10); +} + +function test_reduce_number_noInit_threeArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const sum = arr.reduce((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduce_number_noInit_twoArgs(): void { + const arr = new Uint8ClampedArray([5, 2, 7]); + const sum = arr.reduce((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduce_number_noInit_oneArg(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const res = arr.reduce((prev: number): number => prev + 1); + // No initialValue => 3 calls for length=4, starting with first element as prev + arktest.assertEQ(res, arr[0] + 3); +} + +function test_reduce_number_noInit_zeroArgs(): void { + const arr = new Uint8ClampedArray([9, 8, 7]); + const res = arr.reduce((): number => 123); + arktest.assertEQ(res, 123); +} + +/* reduce – number with initialValue */ + +function test_reduce_number_withInit_fullArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint8ClampedArray): number => prev + cur, 10); + arktest.assertEQ(sum, 20); +} + +/* reduce – generic with initialValue, varying arity */ + +function test_reduce_generic_string_fullArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const joined = arr.reduce( + (prev: string, cur: number, idx: number, a: Uint8ClampedArray): string => prev + `-${cur}@${idx}`, + "start" + ); + arktest.assertEQ(joined, "start-1@0-2@1-3@2"); +} + +function test_reduce_generic_object_threeArgs(): void { + const arr = new Uint8ClampedArray([2, 4, 6]); + const acc = arr.reduce((prev: AccSumCount, cur: number, idx: number): AccSumCount => { + prev.sum += cur; + prev.count += 1; + return prev; + }, new AccSumCount(0, 0)); + arktest.assertEQ(acc.sum, 12); + arktest.assertEQ(acc.count, 3); +} + +function test_reduce_generic_boolean_twoArgs(): void { + const arr = new Uint8ClampedArray([1, 3, 5, 7]); + const allOdd = arr.reduce((prev: boolean, cur: number): boolean => prev && (cur % 2 !== 0), true); + arktest.assertTrue(allOdd); +} + +function test_reduce_generic_number_oneArg(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const calls = arr.reduce((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 4); +} + +function test_reduce_generic_number_zeroArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const res = arr.reduce(() => 7, 100); + arktest.assertEQ(res, 7); +} + +/* reduce – index and array param verification */ + +function test_reduce_index_and_array_params(): void { + const arr = new Uint8ClampedArray([10, 20, 30]); + let seenSameArray = true; + const visited: number[] = []; + const sum = arr.reduce((prev: number, cur: number, idx: number, a: Uint8ClampedArray): number => { + if (a !== arr) seenSameArray = false; + visited.push(idx); + return prev + cur; + }); + arktest.assertTrue(seenSameArray); + arktest.assertEQ(visited.length, 2); // no init => indexes 1,2 + arktest.assertEQ(visited[0], 1); + arktest.assertEQ(visited[1], 2); + arktest.assertEQ(sum, 60); +} + +/* reduce – exceptions */ + +function test_reduce_throws_on_empty(): void { + const empty = new Uint8ClampedArray(0); + let threw = false; + try { + empty.reduce((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} + +/* reduceRight – number, no initialValue, varying callback arity */ + +function test_reduceRight_number_noInit_fullArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const diff = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint8ClampedArray): number => prev - cur); + // No initialValue: start prev=4; then 4-3=1; 1-2=-1; -1-1=-2 + arktest.assertEQ(diff, -2); +} + +function test_reduceRight_number_noInit_threeArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const sum = arr.reduceRight((prev: number, cur: number, idx: number): number => prev + cur); + arktest.assertEQ(sum, 6); +} + +function test_reduceRight_number_noInit_twoArgs(): void { + const arr = new Uint8ClampedArray([5, 2, 7]); + const sum = arr.reduceRight((prev: number, cur: number): number => prev + cur); + arktest.assertEQ(sum, 14); +} + +function test_reduceRight_number_noInit_oneArg(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number): number => prev + 1); + arktest.assertEQ(res, arr[3] + 3); +} + +function test_reduceRight_number_noInit_zeroArgs(): void { + const arr = new Uint8ClampedArray([9, 8, 7]); + const res = arr.reduceRight((): number => 50); + arktest.assertEQ(res, 50); +} + +/* reduceRight – number with initialValue */ + +function test_reduceRight_number_withInit_fullArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4]); + const res = arr.reduceRight((prev: number, cur: number, idx: number, a: Uint8ClampedArray): number => prev + cur, 10); + arktest.assertEQ(res, 20); +} + +/* reduceRight – generic with initialValue, varying arity */ + +function test_reduceRight_generic_string_fullArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const joined = arr.reduceRight( + (prev: string, cur: number, idx: number, a: Uint8ClampedArray): string => prev + `(${cur}<${idx})`, + "R" + ); + arktest.assertEQ(joined, "R(3<2)(2<1)(1<0)"); +} + +function test_reduceRight_generic_object_threeArgs(): void { + const arr = new Uint8ClampedArray([2, 4, 6]); + const acc = arr.reduceRight((prev: AccProdSteps, cur: number, idx: number): AccProdSteps => { + prev.prod *= cur; + prev.steps += 1; + return prev; + }, new AccProdSteps(1, 0)); + arktest.assertEQ(acc.prod, 48); + arktest.assertEQ(acc.steps, 3); +} + +function test_reduceRight_generic_boolean_twoArgs(): void { + const arr = new Uint8ClampedArray([2, 4, 6]); + const anyEvenFromRight = arr.reduceRight((prev: boolean, cur: number): boolean => prev || (cur % 2 === 0), false); + arktest.assertTrue(anyEvenFromRight); +} + +function test_reduceRight_generic_number_oneArg(): void { + const arr = new Uint8ClampedArray([1, 2, 3, 4, 5]); + const calls = arr.reduceRight((prev: number): number => prev + 1, 0); + arktest.assertEQ(calls, 5); +} + +function test_reduceRight_generic_number_zeroArgs(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const res = arr.reduceRight(() => -1, 999); + arktest.assertEQ(res, -1); +} + +/* reduceRight – order verification */ + +function test_reduceRight_order_verification(): void { + const arr = new Uint8ClampedArray([1, 2, 3]); + const left = arr.reduce((p: number, c: number) => p * 10 + c, 0); + const right = arr.reduceRight((p: number, c: number) => p * 10 + c, 0); + arktest.assertEQ(left, 123); + arktest.assertEQ(right, 321); +} + +/* reduceRight – exceptions */ + +function test_reduceRight_throws_on_empty(): void { + const empty = new Uint8ClampedArray(0); + let threw = false; + try { + empty.reduceRight((p: number, c: number) => p + c); + } catch (e) { + threw = true; + } + arktest.assertTrue(threw); +} -- Gitee