From 2b3f12462bdb2914013e385189fb7a7641664756 Mon Sep 17 00:00:00 2001 From: Cillinn <1364800211@qq.com> Date: Thu, 11 Sep 2025 10:24:00 +0800 Subject: [PATCH] Fix bug: await is used in non-async function Issue: https://gitee.com/openharmony/arkcompiler_runtime_core/issues/ICXG0J Signed-off-by: Cillinn <1364800211@qq.com> --- .../tests/promise_ops/promise_reject_test.ets | 6 +- .../promise_ops/promise_resolve_test.ets | 4 + .../awaited_parameter.ets | 2 +- .../13.chaining_operator/chop_asyn_func01.ets | 4 +- .../03.async_methods/async_method0.ets | 4 +- .../03.async_methods/async_method1.ets | 4 +- .../03.async_methods/async_method2.ets | 4 +- .../03.async_methods/async_method3.ets | 4 +- .../spec/05.Generics/callFromAsyncLambda.ets | 2 +- .../callAsyncMethodFromAsyncLambda1.ets | 4 +- .../callAsyncMethodFromAsyncLambda2.ets | 4 +- .../callMethodFromAsyncLambda1.ets | 4 +- .../callMethodFromAsyncLambda2.ets | 4 +- .../callRegularLambdaWithAsyncOverload.ets | 4 +- .../resultFromAwait.ets | 2 +- .../enumCallToStringFromAsyncLambda.ets | 2 +- .../std/concurrency/AsyncLockTest.ets | 136 +++++++++--------- .../BlockingQueue/AddAndPollStress.ets | 4 +- .../LinkedBlockingQueue_getEnd.ets | 2 +- .../ets_sdk/api/@ohos/buffer/BlobTest.ets | 92 ++++++------ .../api/@ohos/util/Base64HelperTest.ets | 16 +-- .../ets_sdk/api/@ohos/util/PromisifyTest.ets | 20 +-- .../util/stream/StreamDuplexTestPart1.ets | 12 +- .../util/stream/StreamDuplexTestPart2.ets | 12 +- .../stream/StreamPipeEnCodingTestPart1.ets | 12 +- .../stream/StreamPipeEnCodingTestPart2.ets | 16 +-- .../stream/StreamPipeEnCodingTestPart3.ets | 16 +-- .../stream/StreamPipeEnCodingTestPart4.ets | 16 +-- .../stream/StreamPipeEnCodingTestPart5.ets | 16 +-- .../stream/StreamPipeEnCodingTestPart6.ets | 16 +-- .../stream/StreamPipeEnCodingTestPart7.ets | 16 +-- .../util/stream/StreamReadableTestPart1.ets | 16 +-- .../util/stream/StreamReadableTestPart2.ets | 8 +- .../util/stream/StreamReadableTestPart3.ets | 4 +- .../util/stream/StreamReadableTestPart4.ets | 4 +- .../util/stream/StreamTransformTestPart1.ets | 12 +- .../util/stream/StreamTransformTestPart2.ets | 8 +- .../util/stream/StreamWritableTestPart1.ets | 16 +-- .../util/stream/StreamWritableTestPart2.ets | 16 +-- .../util/stream/StreamWritableTestPart3.ets | 16 +-- .../util/stream/StreamWritableTestPart4.ets | 16 +-- .../util/stream/StreamWritableTestPart5.ets | 16 +-- .../util/stream/StreamWritableTestPart6.ets | 4 +- .../util/stream/StreamWritableTestPart7.ets | 8 +- .../ets_test_suite/coroutines/affinity.ets | 6 +- .../ets_test_suite/coroutines/async_call.ets | 36 ++--- .../await_async_return_reject_promise.ets | 8 +- .../coroutines/await_migrate.ets | 2 +- .../coroutines/await_standalone_promise.ets | 4 +- .../coroutines/elauncher_id.ets | 4 +- .../coroutines/execution_order.ets | 22 +-- .../coroutines/launch_launch.ets | 4 +- .../coroutines/launch_n_workers.ets | 4 +- .../coroutines/launch_return.ets | 28 ++-- .../tests/ets_test_suite/coroutines/stats.ets | 4 +- .../unhandled_rejection_promise.ets | 8 +- .../coroutines/wake_for_another_event.ets | 4 +- .../gc/finalization_registry_coro_test.ets | 4 +- .../finalization_registry_deadlock_test.ets | 17 ++- .../gc/stress/test_stress_gc_humongous.ets | 2 +- .../gc/stress/test_stress_gc_humongous_bq.ets | 2 +- .../tests/interop_js/eacoro/attach_test.ets | 2 +- .../tests/interop_js/eacoro/eaworker_test.ets | 2 +- .../interop_js/taskpool/taskpool_test.ets | 10 +- .../ts_to_ets/taskpool_interop_tests.ets | 48 +++---- .../tests/promise/promise_tests.ets | 2 +- .../exclusive_worker_tests.ets | 10 +- 67 files changed, 426 insertions(+), 411 deletions(-) diff --git a/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_reject_test.ets b/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_reject_test.ets index bf5d65dc5b..b35cf77635 100644 --- a/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_reject_test.ets +++ b/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_reject_test.ets @@ -14,10 +14,14 @@ */ function checkReject(promise: Promise, rejection: Error): boolean { + return waitForCompletion(() => checkRejectAsync(promise, rejection)); +} + +async function checkRejectAsync(promise: Promise, rejection: Error): Promise { try { await promise; return false; } catch (exception: Error) { return exception == rejection; } -} +} \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_resolve_test.ets b/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_resolve_test.ets index 382a15046c..2a185fef54 100644 --- a/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_resolve_test.ets +++ b/static_core/plugins/ets/tests/ani/tests/promise_ops/promise_resolve_test.ets @@ -14,6 +14,10 @@ */ function checkResolve(promise: Promise, resolution: String): boolean { + return waitForCompletion(() => checkResolveAsync(promise, resolution)); +} + +async function checkResolveAsync(promise: Promise, resolution: String): Promise { let value = await promise; return value == resolution; } diff --git a/static_core/plugins/ets/tests/ets-templates/05.generics/03.utility_types/01.awaited_utility_type/awaited_parameter.ets b/static_core/plugins/ets/tests/ets-templates/05.generics/03.utility_types/01.awaited_utility_type/awaited_parameter.ets index 325c903d5c..ad1fbde475 100644 --- a/static_core/plugins/ets/tests/ets-templates/05.generics/03.utility_types/01.awaited_utility_type/awaited_parameter.ets +++ b/static_core/plugins/ets/tests/ets-templates/05.generics/03.utility_types/01.awaited_utility_type/awaited_parameter.ets @@ -25,7 +25,7 @@ async function foo(awaited: Awaited, expected: T) { } function main() { - await foo({{c.awaited_param}}, {{c.expected_param}}) + waitForCompletion(() => foo({{c.awaited_param}}, {{c.expected_param}})) } {% endfor %} diff --git a/static_core/plugins/ets/tests/ets-templates/07.expressions/13.chaining_operator/chop_asyn_func01.ets b/static_core/plugins/ets/tests/ets-templates/07.expressions/13.chaining_operator/chop_asyn_func01.ets index 9703bbc93a..02e0e30ba7 100644 --- a/static_core/plugins/ets/tests/ets-templates/07.expressions/13.chaining_operator/chop_asyn_func01.ets +++ b/static_core/plugins/ets/tests/ets-templates/07.expressions/13.chaining_operator/chop_asyn_func01.ets @@ -29,6 +29,6 @@ class Person { function main(): void { const bob = new Person("Bob"); bob.fetchData = async (): Promise => "Data fetched"; - const a: string = await bob.fetchData!(); + const a: string = waitForCompletion(bob.fetchData!); arktest.assertEQ(a, "Data fetched"); -} \ No newline at end of file +} diff --git a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method0.ets b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method0.ets index c3997cfd91..d2079dabd8 100644 --- a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method0.ets +++ b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method0.ets @@ -24,12 +24,12 @@ class MethodReturnString { } } -function startTest() { +async function startTest() { const example = new MethodReturnString(); const result = await example.methodReturnString(); arktest.assertEQ(result, "Hello, World!"); } function main(): void { - startTest(); + waitForCompletion(startTest); } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method1.ets b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method1.ets index 804d955519..9190c8cb29 100644 --- a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method1.ets +++ b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method1.ets @@ -24,12 +24,12 @@ class MethodReturnInt { } } -function startTest() { +async function startTest() { const example = new MethodReturnInt(); const result = await example.methodReturnInt(); arktest.assertEQ(result, 10); } function main(): void { - startTest(); + waitForCompletion(startTest); } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method2.ets b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method2.ets index 21276bc69b..19ee73ade2 100644 --- a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method2.ets +++ b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method2.ets @@ -24,12 +24,12 @@ class MethodReturnDouble { } } -function startTest() { +async function startTest() { const example = new MethodReturnDouble(); const result = await example.methodReturnDouble(); arktest.assertEQ(result, 10.0); } function main(): void { - startTest(); + waitForCompletion(startTest); } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method3.ets b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method3.ets index ccba65e074..4d044796fd 100644 --- a/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method3.ets +++ b/static_core/plugins/ets/tests/ets-templates/16.concurrency/03.asynchronous_api/03.async_methods/async_method3.ets @@ -28,9 +28,9 @@ class MethodReturnVoid { async function startTest() { const example = new MethodReturnVoid(); - const result = await example.methodReturnVoid(); + await example.methodReturnVoid(); } function main(): void { - startTest(); + waitForCompletion(startTest); } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/05.Generics/callFromAsyncLambda.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/05.Generics/callFromAsyncLambda.ets index d29d3f3884..af5120a040 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/05.Generics/callFromAsyncLambda.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/05.Generics/callFromAsyncLambda.ets @@ -42,5 +42,5 @@ function main(): void { arktest.assertTrue( arr2 instanceof Object) arktest.assertTrue( arr2[0] instanceof Int) } - await foo(); + waitForCompletion(foo); } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda1.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda1.ets index 01ee4d0c88..1aa7276fd9 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda1.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda1.ets @@ -26,7 +26,7 @@ class LambdaTests { return true; } - testCallAsyncLambda(): void { + async testCallAsyncLambda(): Promise { let call_async_lambda = false; let async_lambda: asyncLambda = async (): Promise => { @@ -41,5 +41,5 @@ class LambdaTests { } function main(): void { - new LambdaTests().testCallAsyncLambda(); + waitForCompletion(new LambdaTests().testCallAsyncLambda); } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda2.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda2.ets index b349a0ef79..9ddf9dd843 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda2.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callAsyncMethodFromAsyncLambda2.ets @@ -25,7 +25,7 @@ async function asyncFunc(): Promise { return true; } -function testCallAsyncLambda(): void { +async function testCallAsyncLambda(): Promise { let call_async_lambda = false; let async_lambda: asyncLambda = async (): Promise => { @@ -39,5 +39,5 @@ function testCallAsyncLambda(): void { } function main(): void { - testCallAsyncLambda(); + waitForCompletion(testCallAsyncLambda); } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda1.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda1.ets index a6bf503dde..806ecfb1e1 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda1.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda1.ets @@ -26,7 +26,7 @@ class LambdaTests { return true; } - testCallFromAsyncLambdaRegularFunc(): void { + async testCallFromAsyncLambdaRegularFunc(): Promise { let is_call_async_lambda = false; let async_lambda: asyncLambda = async (): Promise => { @@ -40,5 +40,5 @@ class LambdaTests { } function main(): void { - new LambdaTests().testCallFromAsyncLambdaRegularFunc(); + waitForCompletion(new LambdaTests().testCallFromAsyncLambdaRegularFunc); } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda2.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda2.ets index 205248b0a0..fcfd735810 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda2.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callMethodFromAsyncLambda2.ets @@ -25,7 +25,7 @@ function regularFunc(): boolean { return true; } -function testCallFromAsyncLambdaRegularFunc(): void { +async function testCallFromAsyncLambdaRegularFunc(): Promise { let is_call_async_lambda = false; let async_lambda: asyncLambda = async (): Promise => { is_call_async_lambda = regularFunc(); @@ -36,5 +36,5 @@ function testCallFromAsyncLambdaRegularFunc(): void { } function main(): void { - testCallFromAsyncLambdaRegularFunc(); + waitForCompletion(testCallFromAsyncLambdaRegularFunc); } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callRegularLambdaWithAsyncOverload.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callRegularLambdaWithAsyncOverload.ets index f443845f0c..237744b2f7 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callRegularLambdaWithAsyncOverload.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/callRegularLambdaWithAsyncOverload.ets @@ -28,7 +28,7 @@ class Test { return param(); } - callOverloadRegularFunc(): void { + async callOverloadRegularFunc(): Promise { let is_call_regular_func1 = await this.regularFunc((): boolean => { return true }); arktest.assertEQ(is_call_regular_func1, true) @@ -38,5 +38,5 @@ class Test { } function main(): void { - new Test().callOverloadRegularFunc(); + waitForCompletion(new Test().callOverloadRegularFunc); } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/resultFromAwait.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/resultFromAwait.ets index f482dc6792..0b55da7eed 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/resultFromAwait.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/07.expressions/7.32.Lambda_Expressions/resultFromAwait.ets @@ -32,7 +32,7 @@ function main(): void { let is_true: Boolean = new Boolean(true); - let is_resolution2: Boolean = await booleanPromise(); + let is_resolution2: Boolean = waitForCompletion(booleanPromise); arktest.assertTrue( is_resolution2 instanceof Boolean) arktest.assertEQ(is_resolution2, is_true) diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/11.Enumerations/enumCallToStringFromAsyncLambda.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/11.Enumerations/enumCallToStringFromAsyncLambda.ets index a4b3a1fcc1..9d1bcec587 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/11.Enumerations/enumCallToStringFromAsyncLambda.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/11.Enumerations/enumCallToStringFromAsyncLambda.ets @@ -71,7 +71,7 @@ function main(): void { return Promise.resolve(getString(arg)); }; - let big_string_from_enum: string = await stringPromise(); + let big_string_from_enum: string = waitForCompletion(stringPromise); arktest.assertEQ(expected_big_string, big_string_from_enum) } diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/concurrency/AsyncLockTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/concurrency/AsyncLockTest.ets index d59bf73bac..3514079fd0 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/concurrency/AsyncLockTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/concurrency/AsyncLockTest.ets @@ -16,7 +16,7 @@ /** * Check if lock returns information about current execution state. */ -function asyncLockQueryTest(): int { +async function asyncLockQueryTest(): Promise { let lock = AsyncLock.request("asyncLockQueryTest"); let promise = lock.lockAsync((): int => { let state = lock.query(); @@ -58,7 +58,7 @@ function asyncLockQueryNonexistentNameTest(): int { /** * Check if async lock survives dead lock. */ -function asyncLockDeadLockTest(): int { +async function asyncLockDeadLockTest(): Promise { let lock = new AsyncLock(); let promise = lock.lockAsync((): int => { @@ -79,7 +79,7 @@ function asyncLockDeadLockTest(): int { /** * Check if callback can be interupted because of isAvailable. */ -function asyncLockAvailableTest(): int { +async function asyncLockAvailableTest(): Promise { let lock = new AsyncLock(); let options = new AsyncLockOptions(true, null, 0) @@ -110,7 +110,7 @@ async function testCallbackExclusive(lock: AsyncLock): Promise { /** * Check if in EXCLUSIVE mode callbacks execute one by one for any caller. */ -function asyncLockExclusiveModeTest(): int { +async function asyncLockExclusiveModeTest(): Promise { let lock = new AsyncLock(); @@ -162,8 +162,8 @@ asyncLockAppTestsuite.addTest("twoThreadsAcquireOwnLocks", () => { arktest.assertTrue(twoThreadsAcquireOwnLocks()) }) -asyncLockAppTestsuite.addTest("multipleWakeupTest", () => { - arktest.assertTrue(multipleWakeupTest()) +asyncLockAppTestsuite.addAsyncTest("multipleWakeupTest", async () => { + arktest.assertTrue(waitForCompletion(multipleWakeupTest)) }) asyncLockAppTestsuite.addTest("waitForLock", () => { @@ -247,7 +247,7 @@ async function applyLockJob(lockName: string, mode: AsyncLockMode, tidBuf: Uint3 }, mode); } -function check(p: Promise, currentTest: string): boolean { +async function check(p: Promise, currentTest: string): Promise { try { await p; return true; @@ -256,7 +256,7 @@ function check(p: Promise, currentTest: string): boolean { } } -function check_negative(p: Promise, currentTest: string): boolean { +async function check_negative(p: Promise, currentTest: string): Promise { try { await p; return false; @@ -299,7 +299,7 @@ const Sleep = (ms: int | undefined): Promise => { }); } -function asynclockStateTest1() { +async function asynclockStateTest1() { let lockName = 'Multiplelocktest1' let lock = AsyncLock.request(lockName); lock.lockAsync(async() =>{ @@ -402,7 +402,7 @@ function assertasynclockStateTest4() { arktest.expectNoThrow(() => { asynclockStateTest4(); }); } -function abortTest() { +function abortTest(): boolean { let lock = new AsyncLock(); let s: AbortSignal = {aborted: false, reason: "Aborted"}; let options = new AsyncLockOptions(); @@ -420,10 +420,10 @@ function abortTest() { arktest.assertEQ(err.message, "Aborted", 'Test failed. Wrong error value.'); } ); - return check(p1, "abortTest"); + return waitForCompletion(() => check(p1, "abortTest")); } -function deadlockTest() { +function deadlockTest(): boolean { let lock = new AsyncLock(); let options = new AsyncLockOptions(); options.timeout = 1000; @@ -438,10 +438,10 @@ function deadlockTest() { // setTimeout is needed to force event loop to process AsyncLock's timer setTimeout(() => { }, (options.timeout.toInt())); - return check_negative(p, "deadlockTest"); + return waitForCompletion(() => check_negative(p, "deadlockTest")); } -function nestedDeadlockTest() { +function nestedDeadlockTest(): boolean { let options = new AsyncLockOptions(); options.timeout = 1000; @@ -457,7 +457,7 @@ function nestedDeadlockTest() { // setTimeout is needed to force event loop to process AsyncLock's timer setTimeout(() => { }, (options.timeout.toInt())); - return check_negative(p, "nestedDeadlockTest"); + return waitForCompletion(() => check_negative(p, "nestedDeadlockTest")); } function twoThreadedDeadlockT2(lockNameL1: string, lockNameL2: string, flagBuf: Uint32Array) { @@ -472,7 +472,7 @@ function twoThreadedDeadlockT2(lockNameL1: string, lockNameL2: string, flagBuf: }, AsyncLockMode.EXCLUSIVE); } -function twoLocksSingleTest() { +function twoLocksSingleTest(): boolean { let sab = new ArrayBuffer(4); let flagBuf = new Uint32Array(sab); flagBuf[0] = 0; @@ -489,7 +489,7 @@ function twoLocksSingleTest() { await Promise.resolve(); swapChanged(flagBuf, 2, 0); }, AsyncLockMode.EXCLUSIVE); - return check(Promise.all([p1, p2]), "twoLocksSingleTest"); + return waitForCompletion(() => check(Promise.all([p1, p2]), "twoLocksSingleTest")); } async function exclusiveLockAcquireJob(): Promise { @@ -498,10 +498,10 @@ async function exclusiveLockAcquireJob(): Promise { }, AsyncLockMode.EXCLUSIVE); } -function twoThreadsAcquireOwnLocks() { +function twoThreadsAcquireOwnLocks(): boolean { let p1: Promise = taskpool.execute(exclusiveLockAcquireJob) as Promise; let p2: Promise = taskpool.execute(exclusiveLockAcquireJob) as Promise; - return check(Promise.all([p1, p2]), "twoThreadsAcquireOwnLocks"); + return waitForCompletion(() => check(Promise.all([p1, p2]), "twoThreadsAcquireOwnLocks")); } async function lockJob(lockName: string, flagBuf: Uint32Array): Promise { @@ -513,7 +513,7 @@ async function lockJob(lockName: string, flagBuf: Uint32Array): Promise { }, AsyncLockMode.SHARED); } -function multipleWakeupTest() { +async function multipleWakeupTest(): Promise { let lockName = "multipleWakeupLock"; let sab = new ArrayBuffer(4); let flagBuf = new Uint32Array(sab); @@ -545,11 +545,11 @@ async function waitForLockBody() { arktest.assertEQ(flagBuf[0], 1, "Test failed"); } -function waitForLock() { - return check(waitForLockBody(), "waitForLock"); +function waitForLock(): boolean { + return waitForCompletion(() => check(waitForLockBody(), "waitForLock")); } -function dontWaitForLock() { +function dontWaitForLock(): boolean { let sab = new ArrayBuffer(4); let flagBuf = new Uint32Array(sab); flagBuf[0] = 0; @@ -558,10 +558,10 @@ function dontWaitForLock() { swapChanged(flagBuf, 0, 1) }, AsyncLockMode.EXCLUSIVE); arktest.assertEQ(flagBuf[0], 0, "Test failed"); - return check(p, "dontWaitForLock"); + return waitForCompletion(() => check(p, "dontWaitForLock")); } -function queryWithDeadlockTest() { +function queryWithDeadlockTest(): boolean { let options = new AsyncLockOptions(); options.timeout = 1000; let lock = new AsyncLock(); @@ -574,7 +574,7 @@ function queryWithDeadlockTest() { let states: AsyncLockState[] = AsyncLock.queryAll(); }, 100); - return check_negative(p, "queryWithDeadlockTest"); + return waitForCompletion(() => check_negative(p, "queryWithDeadlockTest")); } async function lockHolderJob(lockName: string, timeout: number, flagBuf: Uint32Array): Promise { @@ -586,7 +586,7 @@ async function lockHolderJob(lockName: string, timeout: number, flagBuf: Uint32A } -function sequentialLock() { +function sequentialLock(): boolean { let lockNameB = "sequentialLockB"; let sab = new ArrayBuffer(4); let flagBuf = new Uint32Array(sab); @@ -615,10 +615,10 @@ function sequentialLock() { } }); }); - return check(p, "sequentialLock"); + return waitForCompletion(() => check(p, "sequentialLock")); } -function sequentialLockInf() { +function sequentialLockInf(): boolean { let lockNameB = "sequentialLockInfB"; let sab = new ArrayBuffer(4); let flagBuf = new Uint32Array(sab); @@ -647,10 +647,10 @@ function sequentialLockInf() { } }); }); - return check(p, "sequentialLockInf"); + return waitForCompletion(() => check(p, "sequentialLockInf")); } -function sequentialLockUnlocked() { +function sequentialLockUnlocked(): boolean { let sab = new ArrayBuffer(4); let flagBuf = new Uint32Array(sab); flagBuf[0] = 0; @@ -663,10 +663,10 @@ function sequentialLockUnlocked() { }); swapChanged(flagBuf, 2, 3); }); - return check(p, "sequentialLockUnlocked"); + return waitForCompletion(() => check(p, "sequentialLockUnlocked")); } -function sequentialLockUnlocked1() { +function sequentialLockUnlocked1(): boolean { let p = new Promise((resolve: (v :int) => void, reject: (e: Error) => void): void => { let lockA = new AsyncLock(); lockA.lockAsync(/*F1*/ async () => { @@ -683,10 +683,10 @@ function sequentialLockUnlocked1() { }); }); }); - return check(p, "sequentialLockUnlocked1"); + return waitForCompletion(() => check(p, "sequentialLockUnlocked1")); } -function sequentialLockUnlocked3() { +function sequentialLockUnlocked3(): boolean { let p = new Promise((resolve: (v :int) => void, reject: (e: Error) => void): void => { let lockA = new AsyncLock(); lockA.lockAsync(/*F1*/ async () => { @@ -705,19 +705,19 @@ function sequentialLockUnlocked3() { }); }); }); - return check(p, "sequentialLockUnlocked3"); + return waitForCompletion(() => check(p, "sequentialLockUnlocked3")); } -function disarmTimeoutTest() { +function disarmTimeoutTest(): boolean { let lock = new AsyncLock(); let options = new AsyncLockOptions(); options.timeout = 1000; let p: Promise = lock.lockAsync(() => { }, AsyncLockMode.EXCLUSIVE, options); - return check(p, "disarmTimeoutTest"); + return waitForCompletion(() => check(p, "disarmTimeoutTest")); } -function disarmTimeoutLongAwaitTest() { +function disarmTimeoutLongAwaitTest(): boolean { /* * Create an exclusive lock and set the timeout period to 1 second. * In the callback function, await 5 seconds is used to verify that the @@ -733,7 +733,7 @@ function disarmTimeoutLongAwaitTest() { }, 1500); }); }, AsyncLockMode.EXCLUSIVE, options); - return check(p, "disarmTimeoutLongAwaitTest"); + return waitForCompletion(() => check(p, "disarmTimeoutLongAwaitTest")); } function acquireLockTwiceSuccess(outerMode: AsyncLockMode, innerMode: AsyncLockMode, @@ -750,15 +750,17 @@ function acquireLockTwiceSuccess(outerMode: AsyncLockMode, innerMode: AsyncLockM }); } -function acquireLockTwiceSharedSharedAvailable() { - return check(acquireLockTwiceSuccess(AsyncLockMode.SHARED, AsyncLockMode.SHARED, true), "acquireLockTwiceSharedSharedAvailable"); +function acquireLockTwiceSharedSharedAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceSuccess(AsyncLockMode.SHARED, AsyncLockMode.SHARED, true), + "acquireLockTwiceSharedSharedAvailable")); } -function acquireLockTwiceSharedSharedNotAvailable() { - return check(acquireLockTwiceSuccess(AsyncLockMode.SHARED, AsyncLockMode.SHARED, false), "acquireLockTwiceSharedSharedNotAvailable"); +function acquireLockTwiceSharedSharedNotAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceSuccess(AsyncLockMode.SHARED, AsyncLockMode.SHARED, false), + "acquireLockTwiceSharedSharedNotAvailable")); } -function acquireLockTwiceReject(outerMode: AsyncLockMode, innerMode: AsyncLockMode, +async function acquireLockTwiceReject(outerMode: AsyncLockMode, innerMode: AsyncLockMode, isAvailable: boolean): Promise { let lock = new AsyncLock(); return new Promise((resolve: (v : int) => void, reject: (e: Error) => void): void => { @@ -775,28 +777,34 @@ function acquireLockTwiceReject(outerMode: AsyncLockMode, innerMode: AsyncLockMo }); } -function acquireLockTwiceSharedExclusiveAvailable() { - return check(acquireLockTwiceReject(AsyncLockMode.SHARED, AsyncLockMode.EXCLUSIVE, true), "acquireLockTwiceSharedExclusiveAvailable"); +function acquireLockTwiceSharedExclusiveAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceReject(AsyncLockMode.SHARED, AsyncLockMode.EXCLUSIVE, true), + "acquireLockTwiceSharedExclusiveAvailable")); } -function acquireLockTwiceSharedExclusiveNotAvailable() { - return check(acquireLockTwiceSuccess(AsyncLockMode.SHARED, AsyncLockMode.EXCLUSIVE, false), "acquireLockTwiceSharedExclusiveNotAvailable"); +function acquireLockTwiceSharedExclusiveNotAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceSuccess(AsyncLockMode.SHARED, AsyncLockMode.EXCLUSIVE, false), + "acquireLockTwiceSharedExclusiveNotAvailable")); } -function acquireLockTwiceExclusiveSharedAvailable() { - return check(acquireLockTwiceReject(AsyncLockMode.EXCLUSIVE, AsyncLockMode.SHARED, true), "acquireLockTwiceExclusiveSharedAvailable"); +function acquireLockTwiceExclusiveSharedAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceReject(AsyncLockMode.EXCLUSIVE, AsyncLockMode.SHARED, true), + "acquireLockTwiceExclusiveSharedAvailable")); } -function acquireLockTwiceExclusiveSharedNotAvailable() { - return check(acquireLockTwiceSuccess(AsyncLockMode.EXCLUSIVE, AsyncLockMode.SHARED, false), "acquireLockTwiceExclusiveSharedNotAvailable"); +function acquireLockTwiceExclusiveSharedNotAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceSuccess(AsyncLockMode.EXCLUSIVE, AsyncLockMode.SHARED, false), + "acquireLockTwiceExclusiveSharedNotAvailable")); } -function acquireLockTwiceExclusiveExclusiveAvailable() { - return check(acquireLockTwiceReject(AsyncLockMode.EXCLUSIVE, AsyncLockMode.EXCLUSIVE, true), "acquireLockTwiceExclusiveExclusiveAvailable"); +function acquireLockTwiceExclusiveExclusiveAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceReject(AsyncLockMode.EXCLUSIVE, AsyncLockMode.EXCLUSIVE, true), + "acquireLockTwiceExclusiveExclusiveAvailable")); } -function acquireLockTwiceExclusiveExclusiveNotAvailable() { - return check(acquireLockTwiceSuccess(AsyncLockMode.EXCLUSIVE, AsyncLockMode.EXCLUSIVE, false), "acquireLockTwiceExclusiveExclusiveNotAvailable"); +function acquireLockTwiceExclusiveExclusiveNotAvailable(): boolean { + return waitForCompletion(() => check(acquireLockTwiceSuccess(AsyncLockMode.EXCLUSIVE, AsyncLockMode.EXCLUSIVE, false), + "acquireLockTwiceExclusiveExclusiveNotAvailable")); } async function mainExecutor(index: number, flagBuf: Uint32Array, timeout: number) { @@ -820,19 +828,19 @@ async function taskExecutor(flagBuf: Uint32Array, timeout: number) { }, AsyncLockMode.EXCLUSIVE); } -function doubleExitSharedLock() { +function doubleExitSharedLock(): boolean { let sab = new ArrayBuffer(3 * 4); let flagBuf = new Uint32Array(sab); for (let i = 0; i < flagBuf.length; ++i) { flagBuf[i] = 0; } - return check(Promise.all([ + return waitForCompletion(() => check(Promise.all([ mainExecutor(0, flagBuf, 500), mainExecutor(1, flagBuf, 300), // NOTE(mredkin): #23718 signatures needed // taskpool.execute(taskExecutor, flagBuf, 100), launch(taskExecutor, flagBuf, 100), - ]), "doubleExitSharedLock"); + ]), "doubleExitSharedLock")); } function main(): int { @@ -840,10 +848,10 @@ function main(): int { asyncLockTestsuite.addTest("TestWithEqualityAndNonEquality", () => { let failures = 0; - failures += asyncLockQueryTest(); - failures += asyncLockDeadLockTest(); - failures += asyncLockAvailableTest(); - failures += asyncLockExclusiveModeTest(); + failures += waitForCompletion(asyncLockQueryTest); + failures += waitForCompletion(asyncLockDeadLockTest); + failures += waitForCompletion(asyncLockAvailableTest); + failures += waitForCompletion(asyncLockExclusiveModeTest); failures += asyncLockQueryNonexistentNameTest(); arktest.assertEQ(failures, 0); diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets b/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets index 2e832a2262..1e883c849e 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets @@ -16,13 +16,13 @@ function main(): int { let BlockingQueueTestsuite = new arktest.ArkTestsuite("BlockingQueueAddAndPollStressTest") - BlockingQueueTestsuite.addTest("addAndPoll", addAndPoll) + BlockingQueueTestsuite.addAsyncTest("addAndPoll", addAndPoll) let res = BlockingQueueTestsuite.run() CoroutineExtras.stopTaskpool() return res } -function addAndPoll() { +async function addAndPoll() { let queueTestIntA = new containers.ArrayBlockingQueue(10000) let queueTestIntL = new containers.LinkedBlockingQueue(10000) diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/LinkedBlockingQueue_getEnd.ets b/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/LinkedBlockingQueue_getEnd.ets index fcbd74758c..21e77e7f54 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/LinkedBlockingQueue_getEnd.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/LinkedBlockingQueue_getEnd.ets @@ -107,5 +107,5 @@ function getEndConcurrent(testBQ: containers.LinkedBlockingQueue, lock: Asy } }) } - await Promise.all(arrPromise) + waitForCompletion(() => Promise.all(arrPromise)) } diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/buffer/BlobTest.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/buffer/BlobTest.ets index 93351a765a..b3b3e43442 100644 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/buffer/BlobTest.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/buffer/BlobTest.ets @@ -19,43 +19,43 @@ import buffer from "@ohos.buffer" function main(): int { const suite = new arktest.ArkTestsuite("Buffer Blob API tests") - suite.addTest("Test get Blob slice from empty String array", testEmptyStringSlice) - suite.addTest("Test get Blob slice from Chinese String array without options", testChineseStringSlice) - suite.addTest("Test get Blob slice from Chinese and English String array without options", testEnglishStringSlice) - suite.addTest("Test create Blob from String array without options", testBlobFromStringArray) - suite.addTest("Test create Blob from ArrayBuffer without options", testBlobFromArrayBuffer) - suite.addTest("Test create Blob from TypedArray without options", testBlobFromTypedArray) - suite.addTest("Test create Blob from DataView without options", testBlobFromDataView) - suite.addTest("Test create Blob from other Blob without options", testBlobFromBlob) - suite.addTest("Test create Blob from String array with options", testBlobWithOptions) - suite.addTest("Test get Blob slice from String array without options", testStringArraySlice) - suite.addTest("Test get Blob slice from ArrayBuffer without options", testArrayBufferSlice) - suite.addTest("Test get Blob slice from TypedArray without options", testTypedArraySlice) - suite.addTest("Test get Blob slice from DataView without options", testDataViewSlice) - suite.addTest("Test get Blob slice from other Blob without options", testBlobSlice) - suite.addTest("Test get Blob toArrayBuffer", testBlobToArrayBuffer) - suite.addTest("Test get Blob constructor ArrayString", testBlobToArrayString) - suite.addTest("Test get Blob constructor ArrayBuffer", testBlobToArrayArrayBuffer) - suite.addTest("Test get Blob constructor Int8Array", testBlobToArrayInt8Array) - suite.addTest("Test get Blob constructor Uint8Array", testBlobToArrayUint8Array) - suite.addTest("Test get Blob constructor Uint8ClampedArray", testBlobToArrayUint8ClampedArray) + suite.addAsyncTest("Test get Blob slice from empty String array", testEmptyStringSlice) + suite.addAsyncTest("Test get Blob slice from Chinese String array without options", testChineseStringSlice) + suite.addAsyncTest("Test get Blob slice from Chinese and English String array without options", testEnglishStringSlice) + suite.addAsyncTest("Test create Blob from String array without options", testBlobFromStringArray) + suite.addAsyncTest("Test create Blob from ArrayBuffer without options", testBlobFromArrayBuffer) + suite.addAsyncTest("Test create Blob from TypedArray without options", testBlobFromTypedArray) + suite.addAsyncTest("Test create Blob from DataView without options", testBlobFromDataView) + suite.addAsyncTest("Test create Blob from other Blob without options", testBlobFromBlob) + suite.addAsyncTest("Test create Blob from String array with options", testBlobWithOptions) + suite.addAsyncTest("Test get Blob slice from String array without options", testStringArraySlice) + suite.addAsyncTest("Test get Blob slice from ArrayBuffer without options", testArrayBufferSlice) + suite.addAsyncTest("Test get Blob slice from TypedArray without options", testTypedArraySlice) + suite.addAsyncTest("Test get Blob slice from DataView without options", testDataViewSlice) + suite.addAsyncTest("Test get Blob slice from other Blob without options", testBlobSlice) + suite.addAsyncTest("Test get Blob toArrayBuffer", testBlobToArrayBuffer) + suite.addAsyncTest("Test get Blob constructor ArrayString", testBlobToArrayString) + suite.addAsyncTest("Test get Blob constructor ArrayBuffer", testBlobToArrayArrayBuffer) + suite.addAsyncTest("Test get Blob constructor Int8Array", testBlobToArrayInt8Array) + suite.addAsyncTest("Test get Blob constructor Uint8Array", testBlobToArrayUint8Array) + suite.addAsyncTest("Test get Blob constructor Uint8ClampedArray", testBlobToArrayUint8ClampedArray) suite.addTest("Test get Blob constructor Int16Array", testBlobToArrayInt16Array) suite.addTest("Test get Blob constructor Uint16Array", testBlobToArrayUint16Array) - suite.addTest("Test get Blob constructor Uint8Array with options", testBlobToArrayUint8ArrayOptions) + suite.addAsyncTest("Test get Blob constructor Uint8Array with options", testBlobToArrayUint8ArrayOptions) suite.addTest("Test get Blob constructor Int32Array with options", testBlobToInt32Array) suite.addTest("Test get Blob constructor Uint32Array with options", testBlobToUint32Array) suite.addTest("Test get Blob constructor Float32Array with options", testBlobToFloat32Array) suite.addTest("Test get Blob constructor Float64Array with options", testBlobToFloat64Array) suite.addTest("Test get Blob constructor BigInt64Array with options", testBlobToBigInt64Array) suite.addTest("Test get Blob constructor BigUint64Array with options", testBlobToBigUint64Array) - suite.addTest("Test get Blob constructor for string[]", testBlobToBuiltInStringArray) - suite.addTest("Test get Blob constructor from empty", testBlobFromEmpty) + suite.addAsyncTest("Test get Blob constructor for string[]", testBlobToBuiltInStringArray) + suite.addAsyncTest("Test get Blob constructor from empty", testBlobFromEmpty) suite.addTest("Test get Blob constructor from arrays with negative values", testBlobNegative) return suite.run() } -function testEmptyStringSlice() { +async function testEmptyStringSlice() { let sourcesFixed: FixedArray= []; let blobFixed = new buffer.Blob(sourcesFixed) let sizeFixed = blobFixed.size; @@ -77,7 +77,7 @@ function testEmptyStringSlice() { arktest.assertEQ(value.byteLength, 0) } -function testChineseStringSlice() { +async function testChineseStringSlice() { let sources: FixedArray = ['你好', '世界', '测试']; let blob = new buffer.Blob(sources); let size = blob.size; @@ -87,7 +87,7 @@ function testChineseStringSlice() { arktest.assertEQ(text, '你好世界测试') } -function testEnglishStringSlice() { +async function testEnglishStringSlice() { let sources: FixedArray = ['测试', '$#', 'c']; let blob = new buffer.Blob(sources) let size = blob.size; @@ -97,7 +97,7 @@ function testEnglishStringSlice() { arktest.assertEQ(text, '测试$#c') } -function testBlobFromStringArray() { +async function testBlobFromStringArray() { let src: FixedArray = ['1', '2', '3', '4', '5'] let blob = new buffer.Blob(src) arktest.assertEQ(blob.type, '') @@ -106,7 +106,7 @@ function testBlobFromStringArray() { arktest.assertEQ(text, '12345') } -function testBlobFromArrayBuffer() { +async function testBlobFromArrayBuffer() { const arr = new Uint8Array([72, 101, 108, 108, 111]) const arrayBuffer = arr.buffer as ArrayBuffer let src: FixedArray = [arrayBuffer] @@ -117,7 +117,7 @@ function testBlobFromArrayBuffer() { arktest.assertEQ(text, 'Hello') } -function testBlobFromTypedArray() { +async function testBlobFromTypedArray() { let src: FixedArray = [new Int8Array([97, 98, 99, 97, 98])] let blob = new buffer.Blob(src) arktest.assertEQ(blob.size, 5) @@ -126,7 +126,7 @@ function testBlobFromTypedArray() { arktest.assertEQ(text, 'abcab') } -function testBlobFromDataView() { +async function testBlobFromDataView() { const arr = new Uint8Array([72, 101, 108, 108, 111]) const arrayBuffer = arr.buffer as ArrayBuffer const dataView = new DataView(arrayBuffer) @@ -138,7 +138,7 @@ function testBlobFromDataView() { arktest.assertEQ(text, 'HelloHelloHello') } -function testBlobFromBlob() { +async function testBlobFromBlob() { let src = new buffer.Blob(['1', '2', '3', '4', '5']) let blob = new buffer.Blob([src] as FixedArray) arktest.assertEQ(blob.type, '') @@ -147,7 +147,7 @@ function testBlobFromBlob() { arktest.assertEQ(text, '12345') } -function testBlobWithOptions() { +async function testBlobWithOptions() { const blobParts: FixedArray = ['hey!']; const blob = new buffer.Blob(blobParts, { type: 'text/html' } as buffer.BlobOptions); arktest.assertEQ(blob.type, 'text/html') @@ -155,7 +155,7 @@ function testBlobWithOptions() { arktest.assertEQ(text, 'hey!') } -function testStringArraySlice() { +async function testStringArraySlice() { let src: FixedArray = ['1', '2', '3', '4', '5'] let blob = new buffer.Blob(src).slice(0,3) arktest.assertEQ(blob.type, '') @@ -164,7 +164,7 @@ function testStringArraySlice() { arktest.assertEQ(text, '123') } -function testArrayBufferSlice() { +async function testArrayBufferSlice() { let bufferArr = new ArrayBuffer(3); let uint8arr = new Uint8Array(bufferArr); uint8arr[0] = 97; @@ -199,7 +199,7 @@ function testArrayBufferSlice() { arktest.assertEQ(text, 'e') } -function testTypedArraySlice() { +async function testTypedArraySlice() { let src: FixedArray = [new Int8Array([97, 98, 99]), new Int8Array([100, 101]), new Int8Array([102, 103]), @@ -212,7 +212,7 @@ function testTypedArraySlice() { arktest.assertEQ(text, 'a') } -function testDataViewSlice() { +async function testDataViewSlice() { const arr = new Uint8Array([72, 101, 108, 108, 111]); const arr1 = new Uint8Array([97, 98, 99, 100]); const arrayBuffer = arr.buffer as ArrayBuffer; @@ -252,7 +252,7 @@ function testDataViewSlice() { arktest.assertEQ(arrayData[2], 108); } -function testBlobSlice() { +async function testBlobSlice() { let src1 = new buffer.Blob(['1', '2', '3', '4', '5']) let src2 = new buffer.Blob([new Int8Array([1, 2, 3, 4, 5])] as FixedArray) let src3 = new buffer.Blob(['1', '2', '3', '4', '5']) @@ -295,7 +295,7 @@ function testBlobSlice() { } } -function testBlobToArrayBuffer() { +async function testBlobToArrayBuffer() { const arr = new Uint8Array([72, 101, 108, 108, 111]) const arrayBuffer = arr.buffer as ArrayBuffer let src: FixedArray = [new DataView(arrayBuffer)] @@ -306,7 +306,7 @@ function testBlobToArrayBuffer() { arktest.assertEQ(ArrayBuffer.stringify(arrayBufferFromBlob, 'utf8', 0, arrayBufferFromBlob.getByteLength()), text) } -function testBlobToArrayString() { +async function testBlobToArrayString() { let sources = ['测试', '$#', 'c']; let blob = new buffer.Blob(sources) let size = blob.size; @@ -316,7 +316,7 @@ function testBlobToArrayString() { arktest.assertEQ(text, '测试$#c') } -function testBlobToArrayArrayBuffer() { +async function testBlobToArrayArrayBuffer() { let arr = new ArrayBuffer(3); let uint8arr = new Uint8Array(arr); uint8arr[0] = 97; @@ -330,7 +330,7 @@ function testBlobToArrayArrayBuffer() { arktest.assertEQ(text, 'abc') } -function testBlobToArrayInt8Array() { +async function testBlobToArrayInt8Array() { { let src: FixedArray = [new Int8Array([1, 2, 3]), new Int8Array([4, 5]), @@ -380,7 +380,7 @@ function testBlobToArrayInt8Array() { } } -function testBlobToArrayUint8Array() { +async function testBlobToArrayUint8Array() { let uint8arr1 = new Uint8Array(3); uint8arr1[0] = 97; uint8arr1[1] = 98; @@ -393,7 +393,7 @@ function testBlobToArrayUint8Array() { arktest.assertEQ(text, 'abc') } -function testBlobToArrayUint8ClampedArray() { +async function testBlobToArrayUint8ClampedArray() { let uintc8 = new Uint8ClampedArray(3); uintc8 [0] = 100; uintc8 [1] = 101; @@ -429,7 +429,7 @@ function testBlobToArrayUint16Array() { arktest.assertEQ(size, 10) } -function testBlobToArrayUint8ArrayOptions() { +async function testBlobToArrayUint8ArrayOptions() { let o1: buffer.BlobOptions = { type: 'new type', endings: 'transparent' }; let uint8arr1 = new Uint8Array(3); uint8arr1[0] = 97; @@ -540,14 +540,14 @@ function testBlobToBigUint64Array() { -function testBlobToBuiltInStringArray() { +async function testBlobToBuiltInStringArray() { let src: string[] = ['1', '2', '3', '4', '5'] let blob = new buffer.Blob(src) let text = await blob.text() arktest.assertEQ(text, '12345') } -function testBlobFromEmpty() { +async function testBlobFromEmpty() { { let src: string[] = [] let blob = new buffer.Blob(src) diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/Base64HelperTest.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/Base64HelperTest.ets index 56d7a85cbe..260878afa8 100644 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/Base64HelperTest.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/Base64HelperTest.ets @@ -31,12 +31,12 @@ function main(): int { suite.addTest("Test encode and decode with no options", testNoOptionsEncodeDecode); suite.addTest("Test encodeSync and decodeSync with no options", testNoOptionsEncodeDecodeSync); - await testEncodeDecodeBasicAsync(); - await testEncodeDecodeAsyncBytes(); - await testUrlSafeAsync(); - await testDecodeWithNoiseAsync(); - suite.addTest("Test async encode and decode with no options", testNoOptionsEncodeDecodeAsync); - suite.addTest("Test async encode and decode Bytes with no options", testNoOptionsEncodeDecodeAsyncBytes); + waitForCompletion(testEncodeDecodeBasicAsync); + waitForCompletion(testEncodeDecodeAsyncBytes); + waitForCompletion(testUrlSafeAsync); + waitForCompletion(testDecodeWithNoiseAsync); + suite.addAsyncTest("Test async encode and decode with no options", testNoOptionsEncodeDecodeAsync); + suite.addAsyncTest("Test async encode and decode Bytes with no options", testNoOptionsEncodeDecodeAsyncBytes); return suite.run(); } @@ -226,7 +226,7 @@ async function testDecodeWithNoiseAsync(): Promise { assertUint8ArraysEqual(decoded, input); } -function testNoOptionsEncodeDecodeAsync(): void { +async function testNoOptionsEncodeDecodeAsync(): Promise { let helper = new util.Base64Helper(); let input = new Uint8Array([72, 101, 108, 108, 111]); // "Hello" let encodedStr: string = await helper.encodeToString(input); @@ -235,7 +235,7 @@ function testNoOptionsEncodeDecodeAsync(): void { assertUint8ArraysEqual(decoded, input); } -function testNoOptionsEncodeDecodeAsyncBytes(): void { +async function testNoOptionsEncodeDecodeAsyncBytes(): Promise { let helper = new util.Base64Helper(); let input = new Uint8Array([87, 111, 114, 108, 100]); // "World" let encodedBytes: Uint8Array = await helper.encode(input); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/PromisifyTest.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/PromisifyTest.ets index 31cbafe344..9f0b981fd6 100644 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/PromisifyTest.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/PromisifyTest.ets @@ -18,16 +18,16 @@ import {util} from "@ohos.util"; function main(): int { const suite = new arktest.ArkTestsuite("Promisify API tests"); - suite.addTest("Promisify resolves with string", testUtilPromisifyResolvesWithString); - suite.addTest("Promisify rejects with error", testUtilPromisifyRejectsWithError); - suite.addTest("Promisify resolves with number", testUtilPromisifyResolvesWithNumber); - suite.addTest("Promisify resolves with boolean", testUtilPromisifyResolvesWithBoolean); - suite.addTest("Promisify resolves with another number", testUtilPromisifyResolvesWithAnotherNumber); + suite.addAsyncTest("Promisify resolves with string", testUtilPromisifyResolvesWithString); + suite.addAsyncTest("Promisify rejects with error", testUtilPromisifyRejectsWithError); + suite.addAsyncTest("Promisify resolves with number", testUtilPromisifyResolvesWithNumber); + suite.addAsyncTest("Promisify resolves with boolean", testUtilPromisifyResolvesWithBoolean); + suite.addAsyncTest("Promisify resolves with another number", testUtilPromisifyResolvesWithAnotherNumber); return suite.run() } -function testUtilPromisifyResolvesWithString() { +async function testUtilPromisifyResolvesWithString() { let func: Function = (val: Any, callback: (err: Error | null, ...value: FixedArray) => void) => { callback(null, val); } @@ -36,7 +36,7 @@ function testUtilPromisifyResolvesWithString() { arktest.assertEQ(new String(res), 'Hello'); } -function testUtilPromisifyRejectsWithError() { +async function testUtilPromisifyRejectsWithError() { let func: Function = (val: Any, callback: (err: Error | null, ...value: FixedArray) => void) => { if (val instanceof String) { callback(null, val); @@ -51,7 +51,7 @@ function testUtilPromisifyRejectsWithError() { arktest.expectThrow(() => { await value([1, 2]); }, exceptionCheck); } -function testUtilPromisifyResolvesWithNumber() { +async function testUtilPromisifyResolvesWithNumber() { let func: Function = (val: Any, callback: (err: Error | null, ...value: FixedArray) => void) => { callback(null, val); } @@ -60,7 +60,7 @@ function testUtilPromisifyResolvesWithNumber() { arktest.assertEQ(new String(res), '42'); } -function testUtilPromisifyResolvesWithBoolean() { +async function testUtilPromisifyResolvesWithBoolean() { let func: Function = (val: Any, callback: (err: Error | null, ...value: FixedArray) => void) => { callback(null, val); } @@ -69,7 +69,7 @@ function testUtilPromisifyResolvesWithBoolean() { arktest.assertEQ(Boolean(res), true); } -function testUtilPromisifyResolvesWithAnotherNumber() { +async function testUtilPromisifyResolvesWithAnotherNumber() { let func: Function = (val: Any, callback: (err: Error | null, ...value: FixedArray) => void) => { callback(null, val); } diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart1.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart1.ets index cf5a485cd9..2c468085fa 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart1.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart1.ets @@ -21,10 +21,10 @@ function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); suite.addTest("Duplex finish event should not be triggered", testDuplexFinishEventNotTriggered); - suite.addTest("Duplex writableFinished state validation", testDuplexWritableFinishedState); + suite.addAsyncTest("Duplex writableFinished state validation", testDuplexWritableFinishedState); suite.addTest("Duplex basic read and write functionality", testDuplexBasicReadWrite); - suite.addTest("Duplex read with valid size", testDuplexReadWithValidSize); - suite.addTest("Duplex error handling during write", testDuplexErrorHandlingOnWrite); + suite.addAsyncTest("Duplex read with valid size", testDuplexReadWithValidSize); + suite.addAsyncTest("Duplex error handling during write", testDuplexErrorHandlingOnWrite); suite.addTest("Duplex read and write with synchronous data", testDuplexReadWriteWithSyncData); return suite.run(); @@ -137,7 +137,7 @@ class MyDuplex2 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamDuplexWritableFinished002 -function testDuplexWritableFinishedState() { +async function testDuplexWritableFinishedState() { let duplex = new MyDuplex2(); let func: Function = mustCallNoArgs((): void => { arktest.assertTrue(duplex.writableFinished, "writableFinished should be true"); @@ -200,7 +200,7 @@ class MyDuplex4 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamDuplex002 -function testDuplexReadWithValidSize() { +async function testDuplexReadWithValidSize() { mustChecks.push(() => { if (callCount_MyDuplex4 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex4} times.`); @@ -233,7 +233,7 @@ class MyDuplex5 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamDuplex003 -function testDuplexErrorHandlingOnWrite() { +async function testDuplexErrorHandlingOnWrite() { let duplex = new MyDuplex5(); let func: Function = (err: Error) => { arktest.assertEQ(err.message, "Write error", "err.message is valid"); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart2.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart2.ets index 65c7842182..8e7ae6ab7c 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart2.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamDuplexTestPart2.ets @@ -23,9 +23,9 @@ function main(): int { suite.addTest("Duplex writableObjectMode property validation", testDuplexWritableObjectModeProperty); suite.addTest("Duplex writableHighWatermark property validation", testDuplexWritableHighWatermarkProperty); suite.addTest("Duplex readableHighWatermark property validation", testDuplexReadableHighWatermarkProperty); - suite.addTest("Duplex doWritev concatenates chunks correctly", testDuplexDoWritevConcatenatesChunks); - suite.addTest("Duplex doWritev error handling", testDuplexDoWritevErrorHandling); - suite.addTest("Duplex doWritev callback multiple calls handling", testDuplexDoWritevCallbackMultipleCalls); + suite.addAsyncTest("Duplex doWritev concatenates chunks correctly", testDuplexDoWritevConcatenatesChunks); + suite.addAsyncTest("Duplex doWritev error handling", testDuplexDoWritevErrorHandling); + suite.addAsyncTest("Duplex doWritev callback multiple calls handling", testDuplexDoWritevCallbackMultipleCalls); suite.addTest("Duplex write undefined", testDuplexWriteUndefined); suite.addTest("Duplex write empty string", testDuplexWriteEmptyString); @@ -127,7 +127,7 @@ class CustomDuplex1 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamDuplexDoWritev001 -function testDuplexDoWritevConcatenatesChunks() { +async function testDuplexDoWritevConcatenatesChunks() { let duplex = new CustomDuplex1(); let func: Function = mustCallNoArgs((): void => { arktest.assertEQ(duplex.data, 'Hello World'); @@ -147,7 +147,7 @@ class CustomDuplex2 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamDuplexDoWritev002 -function testDuplexDoWritevErrorHandling() { +async function testDuplexDoWritevErrorHandling() { let duplex = new CustomDuplex2(); duplex.on('error', mustCall((err: Error): void => { arktest.assertEQ(err.message, 'dowritev error'); @@ -169,7 +169,7 @@ class CustomDuplex3 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamDuplexDoWritev003 -function testDuplexDoWritevCallbackMultipleCalls() { +async function testDuplexDoWritevCallbackMultipleCalls() { mustChecks.push(() => { if (callCount_CustomDuplex3 !== 1) { throw new Error(`Function was expected to be called 1 times, ` diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart1.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart1.ets index 8d1ca795e4..f56f89a6d2 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart1.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart1.ets @@ -20,9 +20,9 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Pipe data transfer validation.", testPipeDataTransferValidation); - suite.addTest("Pipe with readable and writable streams.", testPipeReadableAndWritableStreams); - suite.addTest("Pipe large data transfer validation.", testPipeLargeDataTransferValidation); + suite.addAsyncTest("Pipe data transfer validation.", testPipeDataTransferValidation); + suite.addAsyncTest("Pipe with readable and writable streams.", testPipeReadableAndWritableStreams); + suite.addAsyncTest("Pipe large data transfer validation.", testPipeLargeDataTransferValidation); return suite.run(); } @@ -102,7 +102,7 @@ class MyWrite1 extends CustomWritable { } } // Test cases ported from ArkTS 1.0:testStreamPipe003 -function testPipeDataTransferValidation() { +async function testPipeDataTransferValidation() { mustChecks.push(() => { if (callCount_MyWrite1 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite1} times.`); @@ -141,7 +141,7 @@ class MyWrite2 extends CustomWritable { } } // Test cases ported from ArkTS 1.0:testStreamPipe004 -function testPipeReadableAndWritableStreams() { +async function testPipeReadableAndWritableStreams() { mustChecks.push(() => { if (callCount_MyWrite2 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite2} times.`); @@ -206,7 +206,7 @@ class MyWrite3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamPipe005 -function testPipeLargeDataTransferValidation() { +async function testPipeLargeDataTransferValidation() { mustChecks.push(() => { if (callCount_MyWrite3 !== 6) { throw new Error(`Function was expected to be called 6 times, but was called ${callCount_MyWrite3} times.`); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart2.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart2.ets index 76e83f1a19..a29e2914e0 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart2.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart2.ets @@ -20,10 +20,10 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Writable stream encoding validation (gb18030).", testWritableStreamWriteEncodingGb18030); - suite.addTest("Writable stream encoding validation (gbk).", testWritableStreamWriteEncodingGbk); - suite.addTest("Writable stream encoding validation (gb2312).", testWritableStreamWriteEncodingGb2312); - suite.addTest("Writable stream end method validation (gb18030).", testWritableStreamEndEncodingGb18030); + suite.addAsyncTest("Writable stream encoding validation (gb18030).", testWritableStreamWriteEncodingGb18030); + suite.addAsyncTest("Writable stream encoding validation (gbk).", testWritableStreamWriteEncodingGbk); + suite.addAsyncTest("Writable stream encoding validation (gb2312).", testWritableStreamWriteEncodingGb2312); + suite.addAsyncTest("Writable stream end method validation (gb18030).", testWritableStreamEndEncodingGb18030); return suite.run(); } @@ -88,7 +88,7 @@ class MyWrite1 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding001 -function testWritableStreamWriteEncodingGb18030() { +async function testWritableStreamWriteEncodingGb18030() { mustChecks.push(() => { if (callCount_MyWrite1 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite1} times.`); @@ -115,7 +115,7 @@ class MyWrite2 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding002 -function testWritableStreamWriteEncodingGbk() { +async function testWritableStreamWriteEncodingGbk() { mustChecks.push(() => { if (callCount_MyWrite2 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite2} times.`); @@ -142,7 +142,7 @@ class MyWrite3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding003 -function testWritableStreamWriteEncodingGb2312() { +async function testWritableStreamWriteEncodingGb2312() { mustChecks.push(() => { if (callCount_MyWrite3 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite3} times.`); @@ -169,7 +169,7 @@ class MyWrite4 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding004 -function testWritableStreamEndEncodingGb18030() { +async function testWritableStreamEndEncodingGb18030() { mustChecks.push(() => { if (callCount_MyWrite4 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite4} times.`); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart3.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart3.ets index 940f2e0e89..f67debb6ca 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart3.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart3.ets @@ -20,10 +20,10 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Writable stream end method validation (gbk).", testWritableStreamEndEncodingGbk); - suite.addTest("Writable stream end method validation (gb2312).", testWritableStreamEndEncodingGb2312); - suite.addTest("Set default encoding validation (gb18030).", testWritableStreamSetDefaultEncodingGb18030); - suite.addTest("Set default encoding validation (gbk).", testWritableStreamSetDefaultEncodingGbk); + suite.addAsyncTest("Writable stream end method validation (gbk).", testWritableStreamEndEncodingGbk); + suite.addAsyncTest("Writable stream end method validation (gb2312).", testWritableStreamEndEncodingGb2312); + suite.addAsyncTest("Set default encoding validation (gb18030).", testWritableStreamSetDefaultEncodingGb18030); + suite.addAsyncTest("Set default encoding validation (gbk).", testWritableStreamSetDefaultEncodingGbk); return suite.run(); } @@ -88,7 +88,7 @@ class MyWrite1 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding005 -function testWritableStreamEndEncodingGbk() { +async function testWritableStreamEndEncodingGbk() { mustChecks.push(() => { if (callCount_MyWrite1 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite1} times.`); @@ -114,7 +114,7 @@ class MyWrite2 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding006 -function testWritableStreamEndEncodingGb2312() { +async function testWritableStreamEndEncodingGb2312() { mustChecks.push(() => { if (callCount_MyWrite2 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite2} times.`); @@ -140,7 +140,7 @@ class MyWrite3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding007 -function testWritableStreamSetDefaultEncodingGb18030() { +async function testWritableStreamSetDefaultEncodingGb18030() { mustChecks.push(() => { if (callCount_MyWrite3 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite3} times.`); @@ -167,7 +167,7 @@ class MyWrite4 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding008 -function testWritableStreamSetDefaultEncodingGbk() { +async function testWritableStreamSetDefaultEncodingGbk() { mustChecks.push(() => { if (callCount_MyWrite4 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite4} times.`); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart4.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart4.ets index 5852ba8efa..e50b1f105b 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart4.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart4.ets @@ -20,13 +20,13 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Set default encoding validation (gb2312).", testWritableStreamSetDefaultEncodingGb2312); + suite.addAsyncTest("Set default encoding validation (gb2312).", testWritableStreamSetDefaultEncodingGb2312); suite.addTest("Readable stream set encoding validation (gb18030).", testReadableStreamSetEncodingGb18030); suite.addTest("Readable stream set encoding validation (gbk).", testReadableStreamSetEncodingGbk); suite.addTest("Readable stream set encoding validation (gb2312).", testReadableStreamSetEncodingGb2312); - suite.addTest("Duplex stream write method validation (gb18030).", testDuplexStreamWriteEncodingGb18030); - suite.addTest("Duplex stream write method validation (gbk).", testDuplexStreamWriteEncodingGbk); - suite.addTest("Duplex stream write method validation (gb2312).", testDuplexStreamWriteEncodingGb2312); + suite.addAsyncTest("Duplex stream write method validation (gb18030).", testDuplexStreamWriteEncodingGb18030); + suite.addAsyncTest("Duplex stream write method validation (gbk).", testDuplexStreamWriteEncodingGbk); + suite.addAsyncTest("Duplex stream write method validation (gb2312).", testDuplexStreamWriteEncodingGb2312); return suite.run(); } @@ -76,7 +76,7 @@ class MyWrite extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamEncoding009 -function testWritableStreamSetDefaultEncodingGb2312() { +async function testWritableStreamSetDefaultEncodingGb2312() { mustChecks.push(() => { if (callCount_MyWrite !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyWrite} times.`); @@ -124,7 +124,7 @@ class MyDuplex1 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding016 -function testDuplexStreamWriteEncodingGb18030() { +async function testDuplexStreamWriteEncodingGb18030() { mustChecks.push(() => { if (callCount_MyDuplex1 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex1} times.`); @@ -150,7 +150,7 @@ class MyDuplex2 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding017 -function testDuplexStreamWriteEncodingGbk() { +async function testDuplexStreamWriteEncodingGbk() { mustChecks.push(() => { if (callCount_MyDuplex2 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex2} times.`); @@ -176,7 +176,7 @@ class MyDuplex3 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding018 -function testDuplexStreamWriteEncodingGb2312() { +async function testDuplexStreamWriteEncodingGb2312() { mustChecks.push(() => { if (callCount_MyDuplex3 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex3} times.`); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart5.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart5.ets index ff18cad4d9..f1675f95bc 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart5.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart5.ets @@ -20,10 +20,10 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Duplex stream end method validation (gb18030).", testDuplexStreamEndEncodingGb18030); - suite.addTest("Duplex stream end method validation (gbk).", testDuplexStreamEndEncodingGbk); - suite.addTest("Duplex stream end method validation (gb2312).", testDuplexStreamEndEncodingGb2312); - suite.addTest("Set default encoding for duplex stream (gb18030).", testDuplexStreamSetDefaultEncodingGb18030); + suite.addAsyncTest("Duplex stream end method validation (gb18030).", testDuplexStreamEndEncodingGb18030); + suite.addAsyncTest("Duplex stream end method validation (gbk).", testDuplexStreamEndEncodingGbk); + suite.addAsyncTest("Duplex stream end method validation (gb2312).", testDuplexStreamEndEncodingGb2312); + suite.addAsyncTest("Set default encoding for duplex stream (gb18030).", testDuplexStreamSetDefaultEncodingGb18030); return suite.run(); } @@ -88,7 +88,7 @@ class MyDuplex1 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding019 -function testDuplexStreamEndEncodingGb18030() { +async function testDuplexStreamEndEncodingGb18030() { mustChecks.push(() => { if (callCount_MyDuplex1 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex1} times.`); @@ -114,7 +114,7 @@ class MyDuplex2 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding020 -function testDuplexStreamEndEncodingGbk() { +async function testDuplexStreamEndEncodingGbk() { mustChecks.push(() => { if (callCount_MyDuplex2 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex2} times.`); @@ -140,7 +140,7 @@ class MyDuplex3 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding021 -function testDuplexStreamEndEncodingGb2312() { +async function testDuplexStreamEndEncodingGb2312() { mustChecks.push(() => { if (callCount_MyDuplex3 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex3} times.`); @@ -165,7 +165,7 @@ class MyDuplex4 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding022 -function testDuplexStreamSetDefaultEncodingGb18030() { +async function testDuplexStreamSetDefaultEncodingGb18030() { mustChecks.push(() => { if (callCount_MyDuplex4 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex4} times.`); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart6.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart6.ets index c598f19e29..87f87fb274 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart6.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart6.ets @@ -20,10 +20,10 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Set default encoding for duplex stream (gbk).", testDuplexStreamSetDefaultEncodingGbk); - suite.addTest("Set default encoding for duplex stream (gb2312).", testDuplexStreamSetDefaultEncodingGb2312); - suite.addTest("Transform stream encoding validation (gb18030).", testTransformStreamWriteEncodingGb18030); - suite.addTest("Transform stream encoding validation (gbk).", testTransformStreamWriteEncodingGbk); + suite.addAsyncTest("Set default encoding for duplex stream (gbk).", testDuplexStreamSetDefaultEncodingGbk); + suite.addAsyncTest("Set default encoding for duplex stream (gb2312).", testDuplexStreamSetDefaultEncodingGb2312); + suite.addAsyncTest("Transform stream encoding validation (gb18030).", testTransformStreamWriteEncodingGb18030); + suite.addAsyncTest("Transform stream encoding validation (gbk).", testTransformStreamWriteEncodingGbk); return suite.run(); } @@ -86,7 +86,7 @@ class MyDuplex1 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding023 -function testDuplexStreamSetDefaultEncodingGbk() { +async function testDuplexStreamSetDefaultEncodingGbk() { mustChecks.push(() => { if (callCount_MyDuplex1 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex1} times.`); @@ -113,7 +113,7 @@ class MyDuplex2 extends stream.Duplex { } } // Test cases ported from ArkTS 1.0:testStreamEncoding024 -function testDuplexStreamSetDefaultEncodingGb2312() { +async function testDuplexStreamSetDefaultEncodingGb2312() { mustChecks.push(() => { if (callCount_MyDuplex2 !== 1) { throw new Error(`Function was expected to be called 1 times, but was called ${callCount_MyDuplex2} times.`); @@ -141,7 +141,7 @@ class MyTransform3 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamEncoding025 -function testTransformStreamWriteEncodingGb18030() { +async function testTransformStreamWriteEncodingGb18030() { mustChecks.push(() => { if (callCount_MyTransform3 !== 1) { throw new Error(`Function was expected to be called 1 times, ` @@ -169,7 +169,7 @@ class MyTransform4 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamEncoding026 -function testTransformStreamWriteEncodingGbk() { +async function testTransformStreamWriteEncodingGbk() { mustChecks.push(() => { if (callCount_MyTransform4 !== 1) { throw new Error(`Function was expected to be called 1 times, ` diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart7.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart7.ets index 80061193e9..84ae48209e 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart7.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamPipeEnCodingTestPart7.ets @@ -20,7 +20,7 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Transform stream encoding validation (gb2312).", testTransformStreamWriteEncodingGb2312); + suite.addAsyncTest("Transform stream encoding validation (gb2312).", testTransformStreamWriteEncodingGb2312); suite.addTest("Readable stream flowing state validation.", testReadableStreamReadableFlowingState); suite.addTest("Readable event triggers validation (3 events).", testReadableStreamOnReadableEventCount3); suite.addTest("Readable event triggers validation (4 events).", testReadableStreamOnReadableEventCount4); @@ -30,11 +30,11 @@ function main(): int { suite.addTest("Pipe data validation with numeric data.", testPipeDataValidationNumericData); suite.addTest("Pipe data validation with multiple destinations.", testPipeDataValidationMultipleDestinations); suite.addTest("Pipe data validation with three destinations.", testPipeDataValidationThreeDestinations); - suite.addTest("Writable stream encoding validation for multiple encodings.", + suite.addAsyncTest("Writable stream encoding validation for multiple encodings.", testWritableStreamWriteMultipleEncodings); - suite.addTest("Writable stream end method validation for multiple encodings.", + suite.addAsyncTest("Writable stream end method validation for multiple encodings.", testWritableStreamEndMultipleEncodings); - suite.addTest("Set default encoding for writable stream with multiple encodings.", + suite.addAsyncTest("Set default encoding for writable stream with multiple encodings.", testWritableStreamSetDefaultEncodingMultipleEncodings); return suite.run(); @@ -134,7 +134,7 @@ class MyTransform1 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamEncoding027 -function testTransformStreamWriteEncodingGb2312() { +async function testTransformStreamWriteEncodingGb2312() { mustChecks.push(() => { if (callCount_MyTransform1 !== 1) { throw new Error(`Function was expected to be called 1 times, ` @@ -427,7 +427,7 @@ class MyWrite10 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamExtraEncoding001 -function testWritableStreamWriteMultipleEncodings() { +async function testWritableStreamWriteMultipleEncodings() { mustChecks.push(() => { if (callCount_MyWrite10 !== 43) { throw new Error(`Function was expected to be called 43 times, ` @@ -460,7 +460,7 @@ class MyWrite11 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamExtraEncoding002 -function testWritableStreamEndMultipleEncodings() { +async function testWritableStreamEndMultipleEncodings() { mustChecks.push(() => { if (callCount_MyWrite11 !== 43) { throw new Error(`Function was expected to be called 43 times, ` @@ -492,7 +492,7 @@ class MyWrite12 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamExtraEncoding003 -function testWritableStreamSetDefaultEncodingMultipleEncodings() { +async function testWritableStreamSetDefaultEncodingMultipleEncodings() { mustChecks.push(() => { if (callCount_MyWrite12 !== 43) { throw new Error(`Function was expected to be called 43 times, ` diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart1.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart1.ets index 114c2e8e89..54d167391f 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart1.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart1.ets @@ -22,15 +22,15 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Readable resume and pause functionality", testReadableResumeAndPause); + suite.addAsyncTest("Readable resume and pause functionality", testReadableResumeAndPause); suite.addTest("Readable pause and read data", testReadablePauseAndRead); - suite.addTest("Readable resume triggers readable event", testReadableResumeTriggersEvent); + suite.addAsyncTest("Readable resume triggers readable event", testReadableResumeTriggersEvent); suite.addTest("Readable isPaused returns false initially", testReadableInitialIsPaused); suite.addTest("Readable isPaused returns true after pause", testReadablePauseUpdatesState); suite.addTest("Readable isPaused returns false after resume", testReadableResumeUpdatesState); suite.addTest("Readable object mode property validation", testReadableObjectModeProperty); suite.addTest("Readable property validation", testReadableDefaultProperty); - suite.addTest("Readable error handling and property update", testReadableErrorHandling); + suite.addAsyncTest("Readable error handling and property update", testReadableErrorHandling); suite.addTest("Readable high watermark property validation", testReadableHighWatermarkProperty); suite.addTest("Readable flowing state validation", testReadableFlowingState); suite.addTest("Readable flowing state after resume", testReadableResumeFlowingState); @@ -43,7 +43,7 @@ function main(): int { suite.addTest("Readable property validation (default state)", testReadableDefaultState); suite.addTest("Readable flowing state validation (with data)", testReadableFlowingWithData); suite.addTest("Readable ended property validation (default state)", testReadableEndedDefaultState); - suite.addTest("Readable ended property validation (after finish)", testReadableEndedAfterFinish); + suite.addAsyncTest("Readable ended property validation (after finish)", testReadableEndedAfterFinish); suite.addTest("Readable property validation (pause and resume)", testReadablePauseAndResumeState); return suite.run(); @@ -97,7 +97,7 @@ function mustCallNoArgs(fn?: Function, times: number = 1) { } // Test cases ported from ArkTS 1.0:testStreamReadableResumePause001 -function testReadableResumeAndPause() { +async function testReadableResumeAndPause() { let readable = new TestReadable(); let dataEmittedAfterResume = false; let dataCalled = false; @@ -132,7 +132,7 @@ function testReadablePauseAndRead() { } // Test cases ported from ArkTS 1.0:testStreamReadableResumePause003 -function testReadableResumeTriggersEvent() { +async function testReadableResumeTriggersEvent() { let readable = new TestReadable(); readable.pause(); readable.on('readable', mustCall()); @@ -187,7 +187,7 @@ class MyRead1 extends stream.Readable { } } // Test cases ported from ArkTS 1.0:testStreamReadableProperties003 -function testReadableErrorHandling() { +async function testReadableErrorHandling() { let readable = new MyRead1(); readable.push('test'); arktest.assertTrue(readable.readable, "readable should be true"); @@ -381,7 +381,7 @@ class MyRead11 extends stream.Readable { } } // Test cases ported from ArkTS 1.0:testStreamReadableProperties016 -function testReadableEndedAfterFinish() { +async function testReadableEndedAfterFinish() { let readable = new MyRead11(); readable.push('Some data'); readable.push(null); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart2.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart2.ets index 595ea295c3..14612eb855 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart2.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart2.ets @@ -22,13 +22,13 @@ function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); suite.addTest("Resume behavior of readable stream", testReadableStreamResumeBehavior); - suite.addTest("Set encoding and readable behavior", testStreamReadableSetEncodingAndReadableBehavior); + suite.addAsyncTest("Set encoding and readable behavior", testStreamReadableSetEncodingAndReadableBehavior); suite.addTest("Data event handling in readable stream", testReadableStreamDataEventBehavior); suite.addTest("Set encoding parameter error in readable stream", testReadableStreamSetEncodingParameterError); suite.addTest("Emit readable event after data push", testReadableStreamEmitReadableBehavior); suite.addTest("Emit readable event for short stream", testReadableStreamEmitReadableShortStreamBehavior); suite.addTest("Readable ended state verification", testReadableStreamReadableEndedBehavior); - suite.addTest("Edge case for readable ended state", testReadableStreamReadableEndedEdgeCase); + suite.addAsyncTest("Edge case for readable ended state", testReadableStreamReadableEndedEdgeCase); suite.addTest("High watermark async behavior in readable stream", testReadableStreamHighWaterMarkAsyncBehavior); return suite.run(); @@ -114,7 +114,7 @@ class MyRead2 extends stream.Readable { } } // Test cases ported from ArkTS 1.0:testStreamReadableData001 -function testStreamReadableSetEncodingAndReadableBehavior() { +async function testStreamReadableSetEncodingAndReadableBehavior() { let readable = new MyRead2(); readable.setEncoding('utf8'); readable.on('readable', (): void => { @@ -220,7 +220,7 @@ function testReadableStreamReadableEndedBehavior() { } // Test cases ported from ArkTS 1.0:testStreamReadableEnded003 -function testReadableStreamReadableEndedEdgeCase() { +async function testReadableStreamReadableEndedEdgeCase() { let readable = new stream.Readable(); readable.on('readable', (): void => { readable.read(); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart3.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart3.ets index 496bd1170e..1fd7fe00f5 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart3.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart3.ets @@ -22,7 +22,7 @@ function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); suite.addTest("Pause and Resume in Readable Stream.", testReadablePauseAndResume) - suite.addTest("Readable property in Readable.", testReadablePropertyReadable) + suite.addAsyncTest("Readable property in Readable.", testReadablePropertyReadable) suite.addTest("Set encoding for Readable.", testReadableSetEncoding) return suite.run(); @@ -95,7 +95,7 @@ class MyRead2 extends stream.Readable { } } // Test cases ported from ArkTS 1.0:testStreamReadableReadable001 -function testReadablePropertyReadable() { +async function testReadablePropertyReadable() { let readable = new MyRead2(); let testMustNotCall = mustNotCall(); arktest.assertEQ(readable.readable, true); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart4.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart4.ets index fa9f399829..07ec5e9e54 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart4.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamReadableTestPart4.ets @@ -21,7 +21,7 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Readable does not implement DoRead.", testReadableErrorOnUnimplementedDoRead); + suite.addAsyncTest("Readable does not implement DoRead.", testReadableErrorOnUnimplementedDoRead); suite.addTest("Reads a buffer of a specified size from the buffer001.", testReadableSetEncodingUtf8); suite.addTest("Reads a buffer of a specified size from the buffer002.", testReadableSetEncodingUtf8Alias); suite.addTest("Reads a buffer of a specified size from the buffer003.", testReadablePushAndReadWithInvalidEncoding); @@ -70,7 +70,7 @@ function mustCall(fn?: Function, times: number = 1) { } // Test cases ported from ArkTS 1.0:testStreamReadableWithUnimplementedDoRead001 -function testReadableErrorOnUnimplementedDoRead() { +async function testReadableErrorOnUnimplementedDoRead() { let readable = new stream.Readable(); readable.on('error', mustCall((error: Error): void => { arktest.assertEQ(error.name, 'BusinessError'); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart1.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart1.ets index e2d9dbd45a..834a176d5b 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart1.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart1.ets @@ -22,18 +22,18 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Call Callback twice in Transform.", testTransformCallbackTwice); + suite.addAsyncTest("Call Callback twice in Transform.", testTransformCallbackTwice); suite.addTest("Transform constructor.", testTransformConstructor); suite.addTest("Event triggering of Transform.", testTransformEventTriggering); suite.addTest("Event handling of Transform.", testTransformEventHandling); suite.addTest("Initialization of Transform.", testTransformInitialization); suite.addTest("Default encoding of Transform.", testTransformDefaultEncoding); - suite.addTest("Read operation of Transform.", testTransformReadOperation); + suite.addAsyncTest("Read operation of Transform.", testTransformReadOperation); suite.addTest("Pause behavior of Transform.", testTransformPauseBehavior); suite.addTest("Resume behavior of Transform.", testTransformResumeBehavior); suite.addTest("Set encoding of Transform.", testTransformSetEncoding); suite.addTest("Pause state of Transform.", testTransformPauseState); - suite.addTest("Read callback of Transform.", testTransformReadCallback); + suite.addAsyncTest("Read callback of Transform.", testTransformReadCallback); suite.addTest("Writable properties of Transform.", testTransformWritableProperties); suite.addTest("Readable properties of Transform.", testTransformReadableProperties); @@ -112,7 +112,7 @@ class MyTransform1 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamTransformCallbackTwice001 -function testTransformCallbackTwice() { +async function testTransformCallbackTwice() { let transform = new MyTransform1(); transform.on('error', mustCall((error: Error): void => { arktest.assertEQ(error.name, 'BusinessError'); @@ -222,7 +222,7 @@ class MyTransform5 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamTransform005 -function testTransformReadOperation() { +async function testTransformReadOperation() { let transformStream = new MyTransform5(); let func: Function = mustCallChunk((chunk: Object): void => { arktest.assertEQ(chunk.toString(), 'x'); @@ -300,7 +300,7 @@ class MyTransform6 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamTransform012 -function testTransformReadCallback() { +async function testTransformReadCallback() { mustChecks.push(() => { if (callCount_MyTransform6 !== 1) { throw new Error(`Function was expected to be called 1 times, ` diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart2.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart2.ets index 5a2123a9ef..13e4eab67c 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart2.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamTransformTestPart2.ets @@ -23,8 +23,8 @@ function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); suite.addTest("Data event of Transform.", testTransformDataEvent); - suite.addTest("Cork and uncork of Transform.", testTransformCorkUncork); - suite.addTest("Error event of Transform.", testTransformErrorEvent); + suite.addAsyncTest("Cork and uncork of Transform.", testTransformCorkUncork); + suite.addAsyncTest("Error event of Transform.", testTransformErrorEvent); suite.addTest("Remove listener of Transform.", testTransformRemoveListener); suite.addTest("Multiple listeners of Transform.", testTransformMultipleListeners); suite.addTest("Flush operation of Transform.", testTransformFlushOperation); @@ -120,7 +120,7 @@ class TestTransform2 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamTransformEvent002 -function testTransformCorkUncork() { +async function testTransformCorkUncork() { mustChecks.push(() => { if (callCount_TestTransform2 !== 1) { throw new Error(`Function was expected to be called 1 times, ` @@ -153,7 +153,7 @@ class TestTransform3 extends stream.Transform { } } // Test cases ported from ArkTS 1.0:testStreamTransformEvent003 -function testTransformErrorEvent() { +async function testTransformErrorEvent() { mustChecks.push(() => { if (callCount_TestTransform3 !== 1) { throw new Error(`Function was expected to be called 1 times, ` diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart1.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart1.ets index ea2897e74c..8d3af9dc0f 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart1.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart1.ets @@ -23,10 +23,10 @@ function main(): int { suite.addTest("Create a writable stream", testWritableCreation); suite.addTest("The state when closing the flow", testWritableCloseState); - suite.addTest("The state of the writable attribute of a writable", testWritableAttributeState); - suite.addTest("Write data to stream", testWritableWriteData); - suite.addTest("DoWrite not called", testWritableDoWriteNotCalled); - suite.addTest("Write data failed", testWritableWriteDataFailed); + suite.addAsyncTest("The state of the writable attribute of a writable", testWritableAttributeState); + suite.addAsyncTest("Write data to stream", testWritableWriteData); + suite.addAsyncTest("DoWrite not called", testWritableDoWriteNotCalled); + suite.addAsyncTest("Write data failed", testWritableWriteDataFailed); suite.addTest("Error on write", testWritableErrorOnWrite); return suite.run(); @@ -122,7 +122,7 @@ class MyWritable1 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritable003 -function testWritableAttributeState() { +async function testWritableAttributeState() { let writableStream = new MyWritable1(); arktest.assertEQ(writableStream.writable, true); writableStream.on('error', mustCall()); @@ -142,7 +142,7 @@ class MyWritable2 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritable004 -function testWritableWriteData() { +async function testWritableWriteData() { let param: Object[] = []; let writableStream = new MyWritable2(); writableStream.write('write content', 'utf8', (...param: Object[]): void => { @@ -165,7 +165,7 @@ class MyWritable3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritable005 -function testWritableDoWriteNotCalled() { +async function testWritableDoWriteNotCalled() { mustChecks.push(() => { if (callCount_MyWritable3 !== 0) { throw new Error(`Function was expected to be called 0 times, ` @@ -190,7 +190,7 @@ class MyWritable4 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableCbError001 -function testWritableWriteDataFailed() { +async function testWritableWriteDataFailed() { let callbackCalled = false; let writable = new MyWritable4(); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart2.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart2.ets index 8a357d502b..9ef82a85db 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart2.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart2.ets @@ -21,10 +21,10 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Multiple callbacks", testWritableMultipleCallbacks); - suite.addTest("Callback repeatedly", testWritableCallbackRepeatedly); - suite.addTest("Callback duplicate", testWritableCallbackDuplicate); - suite.addTest("Write data error", testWritableWriteError); + suite.addAsyncTest("Multiple callbacks", testWritableMultipleCallbacks); + suite.addAsyncTest("Callback repeatedly", testWritableCallbackRepeatedly); + suite.addAsyncTest("Callback duplicate", testWritableCallbackDuplicate); + suite.addAsyncTest("Write data error", testWritableWriteError); suite.addTest("Unknown encoding error", testWritableUnknownEncoding); return suite.run(); @@ -89,7 +89,7 @@ class MyWritable1 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableCbTwice001 -function testWritableMultipleCallbacks() { +async function testWritableMultipleCallbacks() { mustChecks.push(() => { if (callCount_MyWritable1 !== 1) { throw new Error(`Function was expected to be called 1 times, ` @@ -119,7 +119,7 @@ class MyWritable2 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableCbTwice002 -function testWritableCallbackRepeatedly() { +async function testWritableCallbackRepeatedly() { let writableStream = new MyWritable2(); writableStream.write('test'); writableStream.on('error', mustCall((error: Error): void => { @@ -144,7 +144,7 @@ class MyWritable3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableCbTwice003 -function testWritableCallbackDuplicate() { +async function testWritableCallbackDuplicate() { let writableStream = new MyWritable3(); writableStream.write('test'); writableStream.on('error', mustCall((error: Error): void => { @@ -163,7 +163,7 @@ class MyWritable4 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWriteError001 -function testWritableWriteError() { +async function testWritableWriteError() { let writableStream = new MyWritable4(); let ticked = false; writableStream.end(); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart3.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart3.ets index a04b0113c0..f4e996c220 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart3.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart3.ets @@ -21,10 +21,10 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Writev finish event", testWritableWritevFinish); - suite.addTest("Writev error", testWritableWritevError); - suite.addTest("Writev error scenario one", testWritableWritevErrorScenarioOne); - suite.addTest("Writev error scenario two", testWritableWritevErrorScenarioTwo); + suite.addAsyncTest("Writev finish event", testWritableWritevFinish); + suite.addAsyncTest("Writev error", testWritableWritevError); + suite.addAsyncTest("Writev error scenario one", testWritableWritevErrorScenarioOne); + suite.addAsyncTest("Writev error scenario two", testWritableWritevErrorScenarioTwo); return suite.run(); } @@ -76,7 +76,7 @@ class MyWritable1 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritevFinish001 -function testWritableWritevFinish() { +async function testWritableWritevFinish() { let writableStream = new MyWritable1(); writableStream.on('finish', mustNotCall()); writableStream.on('prefinish', mustNotCall()); @@ -99,7 +99,7 @@ class MyWritable2 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritevFinish002 -function testWritableWritevError() { +async function testWritableWritevError() { let writable = new MyWritable2(); writable.on('finish', mustNotCall()); writable.on('prefinish', mustNotCall()); @@ -124,7 +124,7 @@ class MyWritable3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritevFinish003 -function testWritableWritevErrorScenarioOne() { +async function testWritableWritevErrorScenarioOne() { let writable = new MyWritable3(); writable.on('finish', mustNotCall()); writable.on('prefinish', mustNotCall()); @@ -157,7 +157,7 @@ class MyWritable4 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritevFinish004 -function testWritableWritevErrorScenarioTwo() { +async function testWritableWritevErrorScenarioTwo() { let writable = new MyWritable4(); writable.on('finish', mustNotCall()); writable.on('prefinish', mustNotCall()); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart4.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart4.ets index f714f812d9..72093e3b1d 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart4.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart4.ets @@ -21,12 +21,12 @@ const mustChecks: Array = new Array(); function main(): int { const suite = new arktest.ArkTestsuite("Stream API tests"); - suite.addTest("Pipe error handling", testStreamWritablePipeErrorHandling); - suite.addTest("Write after finish error", testStreamWritableWriteAfterFinishError); + suite.addAsyncTest("Pipe error handling", testStreamWritablePipeErrorHandling); + suite.addAsyncTest("Write after finish error", testStreamWritableWriteAfterFinishError); suite.addTest("Write after finish error", testStreamWritableConstructorSetMethodsError); - suite.addTest("End event error", testWritableEndEventError); + suite.addAsyncTest("End event error", testWritableEndEventError); suite.addTest("Writable ended state", testWritableEndedState); - suite.addTest("Writable finished state", testWritableFinishedState); + suite.addAsyncTest("Writable finished state", testWritableFinishedState); suite.addTest("Writable finish event", testWritableFinishEvent); suite.addTest("Writable prefinish event", testWritablePrefinishEvent); suite.addTest("Writable finish sync state", testWritableFinishSyncState); @@ -89,7 +89,7 @@ class MyWritable1 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritevFinish005 -function testStreamWritablePipeErrorHandling() { +async function testStreamWritablePipeErrorHandling() { let readableStream = new MyRead1(); readableStream.push('ok'); readableStream.push(null); @@ -118,7 +118,7 @@ class MyWritable2 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritevFinish006 -function testStreamWritableWriteAfterFinishError() { +async function testStreamWritableWriteAfterFinishError() { let writableStream = new MyWritable2(); writableStream.on('error', mustCall((error: Error): void => { arktest.assertEQ(error.message, 'Write after end.'); @@ -154,7 +154,7 @@ class MyWritable3 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableEndCbError001 -function testWritableEndEventError() { +async function testWritableEndEventError() { const _error = new Error('new error'); let writable = new MyWritable3(); writable.on('error', mustCall((error: Error): void => { @@ -206,7 +206,7 @@ class MyWritable5 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableFinished002 -function testWritableFinishedState() { +async function testWritableFinishedState() { let writable = new MyWritable5(); writable.on('finish', mustCall((): void => { arktest.assertEQ(writable.writableFinished, true); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart5.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart5.ets index 3901919f01..bdcacb009e 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart5.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart5.ets @@ -29,15 +29,15 @@ function main(): int { suite.addTest("Writable initial length", testWritableInitialLength); suite.addTest("Custom writable length", testCustomWritableLength); suite.addTest("Custom writable length after multiple writes", testCustomWritableLengthAfterMultipleWrites); - suite.addTest("Writable length after finish", testWritableLengthAfterFinish); + suite.addAsyncTest("Writable length after finish", testWritableLengthAfterFinish); suite.addTest("Writable write large data", testWritableWriteLargeData); - suite.addTest("Writable drain after large data", testWritableDrainAfterLargeData); - suite.addTest("Writable drain event", testWritableDrainEvent); + suite.addAsyncTest("Writable drain after large data", testWritableDrainAfterLargeData); + suite.addAsyncTest("Writable drain event", testWritableDrainEvent); suite.addTest("Writable state after end", testWritableStateAfterEnd); suite.addTest("Writable cork uncork state", testWritableCorkUncorkState); suite.addTest("Writable error event", testWritableErrorEvent); suite.addTest("Writable error handling", testWritableErrorHandling); - suite.addTest("Writable close event", testWritableCloseEvent); + suite.addAsyncTest("Writable close event", testWritableCloseEvent); return suite.run(); } @@ -168,7 +168,7 @@ function testCustomWritableLengthAfterMultipleWrites() { } // Test cases ported from ArkTS 1.0:testStreamWritableProperties009 -function testWritableLengthAfterFinish() { +async function testWritableLengthAfterFinish() { let customWritable = new CustomWritable(); customWritable.write('hello'); arktest.assertEQ(customWritable.writableLength, 5); @@ -197,7 +197,7 @@ function testWritableWriteLargeData() { } // Test cases ported from ArkTS 1.0:testStreamWritableProperties011 -function testWritableDrainAfterLargeData() { +async function testWritableDrainAfterLargeData() { const largeData = 'ab'.repeat(Math.floor(16384 / 2)); let writableStream = new CustomWritable(); writableStream.write(largeData); @@ -212,7 +212,7 @@ function testWritableDrainAfterLargeData() { } // Test cases ported from ArkTS 1.0:testStreamWritableProperties012 -function testWritableDrainEvent() { +async function testWritableDrainEvent() { const largeData = 'ab'.repeat(Math.floor(16384 / 2)); let writableStream = new CustomWritable(); writableStream.write(largeData); @@ -264,7 +264,7 @@ function testWritableErrorHandling() { } // Test cases ported from ArkTS 1.0:testStreamWritableProperties017 -function testWritableCloseEvent() { +async function testWritableCloseEvent() { let writableStream = new stream.Writable(); writableStream.on('close', mustCall((): void => { arktest.assertEQ(writableStream.writableFinished, true); diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart6.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart6.ets index 5f20a63c3c..cfc6ae11e5 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart6.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart6.ets @@ -32,7 +32,7 @@ function main(): int { suite.addTest("Writable set default encoding empty string", testWritableSetDefaultEncodingEmptyString); suite.addTest("Writable default encoding behavior", testWritableDefaultEncodingBehavior); suite.addTest("Writable drain event high watermark", testWritableDrainEventHighWatermark); - suite.addTest("Writable drain event async high watermark", testWritableDrainEventAsyncHighWatermark); + suite.addAsyncTest("Writable drain event async high watermark", testWritableDrainEventAsyncHighWatermark); return suite.run(); } @@ -297,7 +297,7 @@ class MyWritable7 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableWritev001 -function testWritableDrainEventAsyncHighWatermark() { +async function testWritableDrainEventAsyncHighWatermark() { mustChecks.push(() => { if (callCount_MyWritable7 !== 1) { throw new Error(`Function was expected to be called 1 times, ` diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart7.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart7.ets index 13f116275f..6ff7239b5e 100755 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart7.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/stream/StreamWritableTestPart7.ets @@ -29,7 +29,7 @@ function main(): int { suite.addTest("Check writable length after doWritev", testWritableLengthAfterDoWritev); suite.addTest("Check writable length after async doWritev", testWritableLengthAfterAsyncDoWritev); suite.addTest("Verify callback after doWrite", testWritableAfterDoWriteCallback); - suite.addTest("Verify doWrite order", testWritableDoWriteOrder); + suite.addAsyncTest("Verify doWrite order", testWritableDoWriteOrder); suite.addTest("Verify doWritev order", testWritableDoWritevOrder); suite.addTest("Handle write after end error", testStreamWritableWriteAfterEnd); suite.addTest("Handle end after cork without uncork", testStreamWritableEndAfterCork); @@ -38,7 +38,7 @@ function main(): int { suite.addTest("Verify drain event with high watermark", testWritableDrainEventHighWatermark); suite.addTest("Verify drain event with async high watermark", testWritableDrainEventHighWatermarkAsync); suite.addTest("Handle drain event after end", testStreamWritableDrainEventAfterEnd); - suite.addTest("Write uint array data to stream", testWritableWriteUintArrayData); + suite.addAsyncTest("Write uint array data to stream", testWritableWriteUintArrayData); return suite.run() } @@ -269,7 +269,7 @@ class MyWritable9 extends stream.Writable { } } // Test cases ported from ArkTS 1.0:testStreamWritableEnd001 -function testWritableDoWriteOrder() { +async function testWritableDoWriteOrder() { let ticked = false; let writableStream = new MyWritable9(); writableStream.write('pretest'); @@ -491,7 +491,7 @@ class MyWritable18 extends stream.Writable { callback.unsafeCall(); } } -function testWritableWriteUintArrayData() { +async function testWritableWriteUintArrayData() { let param: Object[] = []; let writableStream = new MyWritable18(); let uint8Array = new Uint8Array([11, 22, 33, 44, 55, 66]); diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/affinity.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/affinity.ets index 5529365fdc..19d1c21edb 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/affinity.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/affinity.ets @@ -26,7 +26,7 @@ async function async_coro(): Promise { return CoroutineExtras.getWorkerId(); } -function check_async_id(): int { +async function check_async_id(): Promise { let id_current: int = CoroutineExtras.getWorkerId(); let id_coro: int = (await async_coro()) as int; if (id_current != id_coro) { @@ -62,7 +62,7 @@ function check_sync_id_nonmain(number_of_coros: int): int { function check_default_policy(): int { L.log('Testing the DEFAULT affinity type'); - if (check_async_id() != 0) { + if (waitForCompletion(check_async_id) != 0) { L.logError('async function worker ID is different from launcher function worker ID'); return 1; } @@ -73,7 +73,7 @@ function check_nonmain_policy(): int { L.log('Testing the NON_MAIN affinity type'); CoroutineExtras.setSchedulingPolicy(CoroutineExtras.POLICY_NON_MAIN); - if (check_async_id() != 0) { + if (waitForCompletion(check_async_id) != 0) { L.logError('async function worker ID is different from launcher function worker ID'); return 1; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/async_call.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/async_call.ets index c8617e7af7..2e3d92adc8 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/async_call.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/async_call.ets @@ -197,63 +197,63 @@ try { arktest.assertTrue(e instanceof InvalidCoroutineOperationError); } -function testNoArgsStaticFuncCall(): void { +async function testNoArgsStaticFuncCall(): Promise { prepare(); let p = foo(); arktest.assertTrue(called); await p; } -function testAmd64SmallFuncCall(): void { +async function testAmd64SmallFuncCall(): Promise { prepare(); let p = amd64_small(1, 2, 3, 4, 5, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0); arktest.assertTrue(called); await p; } -function testAmd64LargeFuncCall(): void { +async function testAmd64LargeFuncCall(): Promise { prepare(); let p = amd64_large(1, 2, 3, 4, 5, 6, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0); arktest.assertTrue(called); await p; } -function testArm32SmallFuncCall(): void { +async function testArm32SmallFuncCall(): Promise { prepare(); let p = arm32_small(1, 2, 3); arktest.assertTrue(called); await p; } -function testArm32LargeFuncCall(): void { +async function testArm32LargeFuncCall(): Promise { prepare(); let p = arm32_large(1, 2, 3, 4, 5); arktest.assertTrue(called); await p; } -function testArm32hfSmallFuncCall(): void { +async function testArm32hfSmallFuncCall(): Promise { prepare(); let p = arm32hf_small(1, 2, 3, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0); arktest.assertTrue(called); await p; } -function testArm32hfLargeFuncCall(): void { +async function testArm32hfLargeFuncCall(): Promise { prepare(); let p = arm32hf_large(1, 2, 3, 4, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0); arktest.assertTrue(called); await p; } -function testArm64SmallFuncCall(): void { +async function testArm64SmallFuncCall(): Promise { prepare(); let p = arm64_small(1, 2, 3, 4, 5, 6, 7, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0); arktest.assertTrue(called); await p; } -function testArm64LargeFuncCall(): void { +async function testArm64LargeFuncCall(): Promise { prepare(); let p = arm64_large(1, 2, 3, 4, 5, 6, 7, 8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0); arktest.assertTrue(called); @@ -262,15 +262,15 @@ function testArm64LargeFuncCall(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.async_call'); - testSuite.addTest('testNoArgsStaticFuncCall', testNoArgsStaticFuncCall); - testSuite.addTest('testAmd64SmallFuncCall', testAmd64SmallFuncCall); - testSuite.addTest('testAmd64LargeFuncCall', testAmd64LargeFuncCall); - testSuite.addTest('testArm32SmallFuncCall', testArm32SmallFuncCall); - testSuite.addTest('testArm32LargeFuncCall', testArm32LargeFuncCall); - testSuite.addTest('testArm32hfSmallFuncCall', testArm32hfSmallFuncCall); - testSuite.addTest('testArm32hfLargeFuncCall', testArm32hfLargeFuncCall); - testSuite.addTest('testArm64SmallFuncCall', testArm64SmallFuncCall); - testSuite.addTest('testArm64LargeFuncCall', testArm64LargeFuncCall); + testSuite.addAsyncTest('testNoArgsStaticFuncCall', testNoArgsStaticFuncCall); + testSuite.addAsyncTest('testAmd64SmallFuncCall', testAmd64SmallFuncCall); + testSuite.addAsyncTest('testAmd64LargeFuncCall', testAmd64LargeFuncCall); + testSuite.addAsyncTest('testArm32SmallFuncCall', testArm32SmallFuncCall); + testSuite.addAsyncTest('testArm32LargeFuncCall', testArm32LargeFuncCall); + testSuite.addAsyncTest('testArm32hfSmallFuncCall', testArm32hfSmallFuncCall); + testSuite.addAsyncTest('testArm32hfLargeFuncCall', testArm32hfLargeFuncCall); + testSuite.addAsyncTest('testArm64SmallFuncCall', testArm64SmallFuncCall); + testSuite.addAsyncTest('testArm64LargeFuncCall', testArm64LargeFuncCall); let res = testSuite.run(); return res; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_async_return_reject_promise.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_async_return_reject_promise.ets index bdabe2f574..49bb2869e6 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_async_return_reject_promise.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_async_return_reject_promise.ets @@ -27,7 +27,7 @@ async function returnRejectingPromise(): Promise { }) } -function testRejectedPromise(): void { +async function testRejectedPromise(): Promise { try { await returnRejectedPromise(); arktest.assertTrue(false, 'Awaited a reject Promise should throw the reason.'); @@ -37,7 +37,7 @@ function testRejectedPromise(): void { } } -function testRejectingPromise(): void { +async function testRejectingPromise(): Promise { try { await returnRejectingPromise(); arktest.assertTrue(false, 'Awaited a reject Promise should throw the reason.'); @@ -49,8 +49,8 @@ function testRejectingPromise(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.await_async_return_reject_promise'); - testSuite.addTest('testRejectedPromise', testRejectedPromise); - testSuite.addTest('testRejectingPromise', testRejectingPromise); + testSuite.addAsyncTest('testRejectedPromise', testRejectedPromise); + testSuite.addAsyncTest('testRejectingPromise', testRejectingPromise); let res = testSuite.run(); return res; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_migrate.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_migrate.ets index 0bb6a6f3c7..bdb1cea271 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_migrate.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_migrate.ets @@ -38,7 +38,7 @@ async function awaitee(): Promise { function testLaunch(): void { let wId = CoroutineExtras.getWorkerId(); - await awaitee(); + waitForCompletion(awaitee); // migrate to the worker with the least load after await if (wId != CoroutineExtras.getWorkerId()) { isLaunchMigrated.set(true); diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_standalone_promise.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_standalone_promise.ets index d0147795c4..33a5dcf077 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_standalone_promise.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/await_standalone_promise.ets @@ -13,7 +13,7 @@ * limitations under the License. */ -function testAwaitStandalonePromise(): void { +async function testAwaitStandalonePromise(): Promise { let value = await Promise.resolve(42); arktest.assertEQ(value, 42, 'Awaited value of resolved promise is different\ from the expected value. Actual value: ' + value); @@ -27,7 +27,7 @@ function testAwaitStandalonePromise(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.await_standalone_promise'); - testSuite.addTest('testAwaitStandalonePromise', testAwaitStandalonePromise); + testSuite.addAsyncTest('testAwaitStandalonePromise', testAwaitStandalonePromise); let res = testSuite.run(); return res; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/elauncher_id.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/elauncher_id.ets index ce815a5b59..6c7547eb10 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/elauncher_id.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/elauncher_id.ets @@ -13,7 +13,7 @@ * limitations under the License. */ -function testElauncherId(): void { +async function testElauncherId(): Promise { let resolveFn: (val: number) => void; let p = new Promise((resolve: (val: number) => void) => { resolveFn = resolve; @@ -27,7 +27,7 @@ function testElauncherId(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.elauncher_id'); - testSuite.addTest('testElauncherId', testElauncherId); + testSuite.addAsyncTest('testElauncherId', testElauncherId); let res = testSuite.run(); return res; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/execution_order.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/execution_order.ets index 2fa6385b1f..6ba94db27b 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/execution_order.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/execution_order.ets @@ -53,7 +53,7 @@ async function bar() { executionOrder.checkpoint(5); } -function executionOrderTest(isPending: boolean) { +async function executionOrderTest(isPending: boolean) { executionOrder = new StepSequence(6); promiseIsPending = isPending; executionOrder.checkpoint(0); @@ -63,15 +63,15 @@ function executionOrderTest(isPending: boolean) { executionOrder.checkOrder(); } -function testWithPendingPromise() { +async function testWithPendingPromise() { executionOrderTest(true); } -function testWithResolvedPromise() { +async function testWithResolvedPromise() { executionOrderTest(false); } -function testPromiseBeforeAsync() { +async function testPromiseBeforeAsync() { executionOrder = new StepSequence(4); let af = async () => { executionOrder.checkpoint(0); @@ -106,7 +106,7 @@ async function dealPromise(asyncThen: boolean) { executionOrder.checkpoint(1); } -function testWithPromiseThen() { +async function testWithPromiseThen() { executionOrder = new StepSequence(4); let af = async () => { await dealPromise(false); @@ -116,7 +116,7 @@ function testWithPromiseThen() { executionOrder.checkOrder(); } -function testWithAsyncPromiseThen() { +async function testWithAsyncPromiseThen() { executionOrder = new StepSequence(6); let af = async () => { await dealPromise(true); @@ -130,11 +130,11 @@ function testWithAsyncPromiseThen() { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.execution_order'); - testSuite.addTest('testWithPendingPromise', testWithPendingPromise); - testSuite.addTest('testWithResolvedPromise', testWithResolvedPromise); - testSuite.addTest('testPromiseBeforeAsync', testPromiseBeforeAsync); - testSuite.addTest('testWithPromiseThen', testWithPromiseThen); - testSuite.addTest('testWithAsyncPromiseThen', testWithAsyncPromiseThen); + testSuite.addAsyncTest('testWithPendingPromise', testWithPendingPromise); + testSuite.addAsyncTest('testWithResolvedPromise', testWithResolvedPromise); + testSuite.addAsyncTest('testPromiseBeforeAsync', testPromiseBeforeAsync); + testSuite.addAsyncTest('testWithPromiseThen', testWithPromiseThen); + testSuite.addAsyncTest('testWithAsyncPromiseThen', testWithAsyncPromiseThen); let res = testSuite.run(); return res; } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_launch.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_launch.ets index fd7ff38754..e2176f1ce8 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_launch.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_launch.ets @@ -23,14 +23,14 @@ async function bar() { return foo('A'); } -function testLaunch() { +async function testLaunch() { let res: Promise> = bar(); arktest.assertEQ((await res), 'AA'); } function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.launch_launch'); - testSuite.addTest('testLaunch', testLaunch); + testSuite.addAsyncTest('testLaunch', testLaunch); let res = testSuite.run(); return res; } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_n_workers.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_n_workers.ets index 32c0d3c7b7..9efb2a09a5 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_n_workers.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_n_workers.ets @@ -30,7 +30,7 @@ async function async_chain_element(caller_wid: int, counter: int): Promise return await async_chain_element(caller_wid, counter - 1); } -function async_function_chain(caller_wid: int, chain_len: int): int { +async function async_function_chain(caller_wid: int, chain_len: int): Promise { return await async_chain_element(caller_wid, chain_len); } @@ -38,7 +38,7 @@ function compare_worker_ids_async(chain_len: int): int { L.log('Testing async function chain'); let id_main: int = CoroutineExtras.getWorkerId(); - let result = async_function_chain(id_main, chain_len); + let result = waitForCompletion(() => async_function_chain(id_main, chain_len)); if (result == 0) { L.log('Successfully ran the async function chain') } else { diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_return.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_return.ets index 008d9cc532..a7eae82391 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_return.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/launch_return.ets @@ -60,7 +60,7 @@ function check(test: String): void { } } -function testByteFunc(): void { +async function testByteFunc(): Promise { reset(); let byteP: Promise = byteFunc(); let pThen = byteP.then((value: Object): Object => { @@ -76,7 +76,7 @@ function testByteFunc(): void { check('byteFunc'); } -function testCharFunc(): void { +async function testCharFunc(): Promise { reset(); let charP: Promise = charFunc(); let pThen = charP.then((value: Object): Object => { @@ -92,7 +92,7 @@ function testCharFunc(): void { check('charFunc'); } -function testShortFunc(): void { +async function testShortFunc(): Promise { reset(); let shortP: Promise = shortFunc(); let pThen = shortP.then((value: Object): Object => { @@ -108,7 +108,7 @@ function testShortFunc(): void { check('shortFunc'); } -function testIntFunc(): void { +async function testIntFunc(): Promise { reset(); let intP: Promise = intFunc(); let pThen = intP.then((value: Object): Object => { @@ -124,7 +124,7 @@ function testIntFunc(): void { check('intFunc'); } -function testLongFunc(): void { +async function testLongFunc(): Promise { reset(); let longP: Promise = longFunc(); let pThen = longP.then((value: Object): Object => { @@ -141,7 +141,7 @@ function testLongFunc(): void { check('longFunc'); } -function testFloatFunc(): void { +async function testFloatFunc(): Promise { reset(); let floatP: Promise = floatFunc(); let pThen = floatP.then((value: Object): Object => { @@ -158,7 +158,7 @@ function testFloatFunc(): void { check('floatFunc'); } -function testDoubleFunc(): void { +async function testDoubleFunc(): Promise { reset(); let doubleP: Promise = doubleFunc(); let pThen = doubleP.then((value: Object): Object => { @@ -176,13 +176,13 @@ function testDoubleFunc(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.launch_return'); - testSuite.addTest('testByteFunc', testByteFunc); - testSuite.addTest('testCharFunc', testCharFunc); - testSuite.addTest('testShortFunc', testShortFunc); - testSuite.addTest('testIntFunc', testIntFunc); - testSuite.addTest('testLongFunc', testLongFunc); - testSuite.addTest('testFloatFunc', testFloatFunc); - testSuite.addTest('testDoubleFunc', testDoubleFunc); + testSuite.addAsyncTest('testByteFunc', testByteFunc); + testSuite.addAsyncTest('testCharFunc', testCharFunc); + testSuite.addAsyncTest('testShortFunc', testShortFunc); + testSuite.addAsyncTest('testIntFunc', testIntFunc); + testSuite.addAsyncTest('testLongFunc', testLongFunc); + testSuite.addAsyncTest('testFloatFunc', testFloatFunc); + testSuite.addAsyncTest('testDoubleFunc', testDoubleFunc); let res = testSuite.run(); return res; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/stats.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/stats.ets index aae251d6ff..c6d950e999 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/stats.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/stats.ets @@ -25,7 +25,7 @@ async function async_f(a: int): Promise { return 'Some dummy string:' + a } -function testCoroStats(): void { +async function testCoroStats(): Promise { for (let i = 0; i < 10; ++i) { launch String>(sync_f, 5); } @@ -42,7 +42,7 @@ function testCoroStats(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.stats'); - testSuite.addTest('testCoroStats', testCoroStats); + testSuite.addAsyncTest('testCoroStats', testCoroStats); let res = testSuite.run(); return res; } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/unhandled_rejection_promise.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/unhandled_rejection_promise.ets index 6ff4c5dbae..4fe7d6a509 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/unhandled_rejection_promise.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/unhandled_rejection_promise.ets @@ -27,7 +27,7 @@ class Event { }) } - public wait(): boolean { + public async wait(): Promise { return await this.promise; } @@ -39,7 +39,7 @@ class Event { private resolveFn: ((val: boolean) => void) | null = null; } -function countCheck() { +async function countCheck() { await asynclock.lockAsync(() => { count++; if (count == REJECTION_COUNT) { @@ -49,7 +49,7 @@ function countCheck() { }, AsyncLockMode.EXCLUSIVE); } -function testUnhandledPromiseRejection(): void { +async function testUnhandledPromiseRejection(): Promise { StdProcess.on('unhandledPromiseRejection', (reason: Error, obj: Object): void => { arktest.assertTrue(obj instanceof Promise, 'The object should be of type Promise'); arktest.assertEQ(reason.message, rejectionReason); @@ -91,7 +91,7 @@ function testUnhandledPromiseRejection(): void { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.unhandled_rejection_promise'); - testSuite.addTest('testUnhandledPromiseRejection', testUnhandledPromiseRejection); + testSuite.addAsyncTest('testUnhandledPromiseRejection', testUnhandledPromiseRejection); let res = testSuite.run(); return res; } diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/wake_for_another_event.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/wake_for_another_event.ets index 7c5f45edc0..cce4bc3f48 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/wake_for_another_event.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/wake_for_another_event.ets @@ -23,7 +23,7 @@ async function foo() {} let resolvePromiseFn: ((value: String) => void) | null = null; -function testWakeForEvent() { +async function testWakeForEvent() { let p1 = new Promise((resolve: (value: String) => void): void => { resolvePromiseFn = resolve; }); @@ -45,7 +45,7 @@ function testWakeForEvent() { function main(): int { let testSuite = new arktest.ArkTestsuite('coroutines.wake_for_another_event'); - testSuite.addTest('testWakeForEvent', testWakeForEvent); + testSuite.addAsyncTest('testWakeForEvent', testWakeForEvent); let res = testSuite.run(); return res; } \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_coro_test.ets b/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_coro_test.ets index 9cee00ad6e..81ed9b42f0 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_coro_test.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_coro_test.ets @@ -137,7 +137,7 @@ async function createCoroA(idx: int): Promise> { } -function ctorTests() { +async function ctorTests() { for (let i = 0; i < promise_count; i++) { regs_promise.push(createCoroA(i)); @@ -158,7 +158,7 @@ function main(): void { getSizeTests(registry!); unregisterTests(registry!); - ctorTests(); + waitForCompletion(ctorTests); arktest.assertEQ(cntr, promise_count, "Counter of ctors is not valid"); } diff --git a/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_deadlock_test.ets b/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_deadlock_test.ets index 3310963a91..732fda293f 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_deadlock_test.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/gc/finalization_registry_deadlock_test.ets @@ -19,14 +19,6 @@ let p = new Promise((_resolve: (value: String) => void): void => { resolve = _resolve; }); -let finreg = new FinalizationRegistry((tag: int) => { - if (tag == 1) { - await p; - } else if (tag == 2) { - resolve!("Panda"); - } -}); - function runGC(): void { try { // trigger FinalizationRegistry cleanup @@ -38,7 +30,14 @@ function runGC(): void { } -function deadlockTest(): void { +async function deadlockTest(): Promise { + let finreg = new FinalizationRegistry((tag: int) => { + if (tag == 1) { + await p; + } else if (tag == 2) { + resolve!("Panda"); + } + }); // Regarding the implementation, after GC the callback will be executed // first for register with number 1 and then for number 2 finreg.register(new Object(), 2); diff --git a/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous.ets b/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous.ets index f19c79ee29..332ea613a9 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous.ets @@ -70,7 +70,7 @@ class TestHumongousStress { return maxNumberOfObjects; } - public run(): void { + public async run(): Promise { let maxObjects = this.getHeapSizeInObjects() - NUMBER_OF_FREE_REGIONS; let objPerCoroutine = (maxObjects / this.threadsCount) as int; let lastCoroutuneNumObjects = maxObjects - objPerCoroutine * (this.threadsCount - 1); diff --git a/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous_bq.ets b/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous_bq.ets index fe703237cb..fad24567a7 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous_bq.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/gc/stress/test_stress_gc_humongous_bq.ets @@ -75,7 +75,7 @@ class TestHumongousStress { return new Object(); }; - public run(): void { + public async run(): Promise { let maxObjects = this.getHeapSizeInObjects() - NUMBER_OF_FREE_REGIONS; let objPerCoroutine = (maxObjects / this.threadsCount) as int; let lastCoroutuneNumObjects = maxObjects - objPerCoroutine * (this.threadsCount - 1); diff --git a/static_core/plugins/ets/tests/interop_js/eacoro/attach_test.ets b/static_core/plugins/ets/tests/interop_js/eacoro/attach_test.ets index 3c3a9f2a1d..ece622e9ae 100644 --- a/static_core/plugins/ets/tests/interop_js/eacoro/attach_test.ets +++ b/static_core/plugins/ets/tests/interop_js/eacoro/attach_test.ets @@ -100,7 +100,7 @@ class TestClass { modified = true; }); - await p1; + waitForCompletion(() => p1); try { let value = JSRuntime.getPropertyInt(JSRuntime.getGlobal(), 'value'); diff --git a/static_core/plugins/ets/tests/interop_js/eacoro/eaworker_test.ets b/static_core/plugins/ets/tests/interop_js/eacoro/eaworker_test.ets index 47cbcf5258..66b0160501 100644 --- a/static_core/plugins/ets/tests/interop_js/eacoro/eaworker_test.ets +++ b/static_core/plugins/ets/tests/interop_js/eacoro/eaworker_test.ets @@ -72,7 +72,7 @@ function RunTasksWithJsAsyncCallTest(): void { modified = true; }); - await promise1; + waitForCompletion(() => promise1); try { let value = JSRuntime.getPropertyInt(JSRuntime.getGlobal(), 'value'); diff --git a/static_core/plugins/ets/tests/interop_js/taskpool/taskpool_test.ets b/static_core/plugins/ets/tests/interop_js/taskpool/taskpool_test.ets index a75ba52330..13f9b9cfbf 100644 --- a/static_core/plugins/ets/tests/interop_js/taskpool/taskpool_test.ets +++ b/static_core/plugins/ets/tests/interop_js/taskpool/taskpool_test.ets @@ -31,8 +31,8 @@ function RunTasksWithJsCallTest(): void { let p1 = taskpool.execute(callback); let p2 = taskpool.execute(callback); - let result1 = await p1; - let result2 = await p2; + let result1 = waitForCompletion(() => p1); + let result2 = waitForCompletion(() => p2); arktest.assertEQ(result1, 0); arktest.assertEQ(result2, 0); } @@ -50,7 +50,7 @@ function RunTasksWithJsAsyncCallTest(): void { modified = true; }); - await promise1; + waitForCompletion(() => promise1); try { let value = JSRuntime.getPropertyInt(JSRuntime.getGlobal(), 'value'); @@ -66,7 +66,7 @@ function RunTasksWithJsAsyncCallTest(): void { }; let p = taskpool.execute(callback); - let result = await p; + let result = waitForCompletion(() => p); arktest.assertEQ(result, 0); arktest.assertEQ(CoroutineExtras.isTaskpoolSupportingInterop(), true); CoroutineExtras.stopTaskpool(); @@ -89,7 +89,7 @@ function testCPUTaskDuration(): void { arktest.assertTrue(task.cpuDuration == 0); arktest.assertTrue(task.totalDuration == 0); - await runner.execute(task); + waitForCompletion(() => runner.execute(task)); arktest.assertTrue(task.cpuDuration > 0); arktest.assertTrue(task.totalDuration > 0); diff --git a/static_core/plugins/ets/tests/interop_js/tests/concurrency/ts_to_ets/taskpool_interop_tests.ets b/static_core/plugins/ets/tests/interop_js/tests/concurrency/ts_to_ets/taskpool_interop_tests.ets index 5267734643..7351333bc0 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/concurrency/ts_to_ets/taskpool_interop_tests.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/concurrency/ts_to_ets/taskpool_interop_tests.ets @@ -22,7 +22,7 @@ function testProcessInput() { let res = (res1.toNumber() === 10) && (res2.toString() === 'HELLO') && (!res3.toBoolean()); return res; }; - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -40,7 +40,7 @@ function testCreateArray() { (res2.getProperty(0).toString() === 'a') && (res3.getProperty(0).toBoolean() === true); }; - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -55,7 +55,7 @@ function testGetUser() { return res1.getProperty('id').toNumber() === 123 && res2.getProperty('role').toString() === 'admin'; }; - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -84,7 +84,7 @@ function testUnion() { arktest.assertTrue(dynamicObj.getProperty('unionProp').getProperty('prop').toNumber() === 1); result = true; } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } catch (error) { console.error(error.toString()); arktest.assertFalse(result); @@ -99,7 +99,7 @@ function testBaseClass() { arktest.assertTrue(obj.typeOf() === 'object') arktest.assertTrue(obj.getProperty('baseVal').toNumber() === 1) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testChildClass() { @@ -110,7 +110,7 @@ function testChildClass() { arktest.assertTrue(obj.getProperty('baseVal').toNumber() === 1) arktest.assertTrue(obj.getProperty('childVal').toNumber() === 2) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testBaseFunc() { @@ -119,7 +119,7 @@ function testBaseFunc() { let obj = module.getProperty('baseFunc').invoke() arktest.assertTrue(ESValue.areStrictlyEqual(obj, ESValue.Undefined)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testChildFunc() { @@ -128,7 +128,7 @@ function testChildFunc() { let obj = module.getProperty('childFunc').invoke() arktest.assertTrue(ESValue.areStrictlyEqual(obj, ESValue.Undefined)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testFooBaseObjInvoke() { @@ -138,7 +138,7 @@ function testFooBaseObjInvoke() { let result = fooBaseObj.getProperty('foo').invoke() arktest.assertTrue(ESValue.areStrictlyEqual(result, ESValue.Undefined)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testFooBaseObjInvokeMethod() { @@ -148,7 +148,7 @@ function testFooBaseObjInvokeMethod() { let result = fooBaseObj.invokeMethod('fooFunc') arktest.assertTrue(ESValue.areStrictlyEqual(result, fooBaseObj)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testFooChildObjInvoke() { @@ -158,7 +158,7 @@ function testFooChildObjInvoke() { let result = fooChildObj.getProperty('foo').invoke() arktest.assertTrue(ESValue.areStrictlyEqual(result, ESValue.Undefined)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testFooChildObjInvokeMethod() { @@ -168,7 +168,7 @@ function testFooChildObjInvokeMethod() { let result = fooChildObj.invokeMethod('fooFunc') arktest.assertTrue(ESValue.areStrictlyEqual(result, fooChildObj)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testArrowFuncInvoke() { @@ -177,7 +177,7 @@ function testArrowFuncInvoke() { let result = module.getProperty('arrowFunc').invoke() arktest.assertTrue(ESValue.areStrictlyEqual(result, ESValue.Undefined)) } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testOptionalParams() { @@ -191,7 +191,7 @@ function testOptionalParams() { arktest.assertTrue(module.getProperty('fun2').invoke(ESValue.wrap(1), ESValue.wrap('str'), ESValue.wrap(false)).toBoolean()); arktest.assertTrue(module.getProperty('fun3').invoke(ESValue.wrap(1), ESValue.wrap('str'), ESValue.wrap(false), ESValue.wrap(2)).toBoolean()); } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } @@ -208,7 +208,7 @@ function testError() { res = (err.getProperty('message').toString() == ErrMsg); return res; } - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -224,7 +224,7 @@ function testThrowError() { } return res; } - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -244,7 +244,7 @@ function testCustomThrowError() { } return res; } - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -265,11 +265,11 @@ function testTaskpoolNestedExecute() { let res3 = processInputDy.invoke(ESValue.wrapBoolean(true)); // false return res1.toNumber() === 10 && res2.toString() === 'HELLO' && !res3.toBoolean(); } - let resInner = (await taskpool.execute(callbackInner)) as boolean; + let resInner = (waitForCompletion(() => taskpool.execute(callbackInner))) as boolean; arktest.assertTrue(resInner); return res && resInner; }; - let res = (await taskpool.execute(callback)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(callback))) as boolean; arktest.assertEQ(res, true); } @@ -286,7 +286,7 @@ function testTaskpoolInteropLoop() { arktest.assertEQ(res3.toBoolean(), false); } } - await taskpool.execute(callback); + waitForCompletion(() => taskpool.execute(callback)); } function testSerializeFunc(serializeTestObj: ESValue) { @@ -302,7 +302,7 @@ function testSerializeFunc(serializeTestObj: ESValue) { function testTaskpoolSerialize() { let module = ESValue.load('../../plugins/ets/tests/interop_js/tests/concurrency/concurrency_helpers'); let serializeTestObj = module.getProperty('serializeTestObj'); - let res = (await taskpool.execute(testSerializeFunc, serializeTestObj)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(testSerializeFunc, serializeTestObj))) as boolean; arktest.assertEQ(res, true); } @@ -310,7 +310,7 @@ function testTaskpoolSerializeClassInstantiate() { let module = ESValue.load('../../plugins/ets/tests/interop_js/tests/concurrency/concurrency_helpers'); let SerializeTest = module.getProperty('SerializeTest'); let serializeTestObj = SerializeTest.instantiate('SerializeTest', 1, ['1', '2', '3']); - let res = (await taskpool.execute(testSerializeFunc, serializeTestObj)) as boolean; + let res = (waitForCompletion(() => taskpool.execute(testSerializeFunc, serializeTestObj))) as boolean; arktest.assertEQ(res, true); } @@ -320,7 +320,7 @@ function testTaskpoolSerializeUndefined() { let callback = (value: ESValue) => { arktest.assertTrue(value.isUndefined()); } - await taskpool.execute(callback, serializeObj); + waitForCompletion(() => taskpool.execute(callback, serializeObj)); } function testTaskpoolSerializeNull() { @@ -329,7 +329,7 @@ function testTaskpoolSerializeNull() { let callback = (value: ESValue) => { arktest.assertTrue(value.isNull()); } - await taskpool.execute(callback, serializeObj); + waitForCompletion(() => taskpool.execute(callback, serializeObj)); } function taskpoolInteropTest() { diff --git a/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets b/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets index 54c025f8fd..0697469609 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets @@ -401,7 +401,7 @@ function testAwaitPromise(): int { let p2: Promise = asyncLambdaAwait(); let p3: Promise = asyncFuncAwaitRejected(); // execute async func (post await part) before check - await Promise.all([p1, p2, p3]); + waitForCompletion(() => Promise.all([p1, p2, p3])); if (unresolved1 != "resolved" || unresolved2 != "resolved") { globalTest!.fail(); } diff --git a/static_core/plugins/ets/tests/native/exclusive_worker/exclusive_worker_tests.ets b/static_core/plugins/ets/tests/native/exclusive_worker/exclusive_worker_tests.ets index c28dd15409..624d37d601 100644 --- a/static_core/plugins/ets/tests/native/exclusive_worker/exclusive_worker_tests.ets +++ b/static_core/plugins/ets/tests/native/exclusive_worker/exclusive_worker_tests.ets @@ -38,7 +38,7 @@ function asyncCall(): boolean { let l = async (): Promise => { return Promise.resolve(call()); } - return await l(); + return waitForCompletion(l); } // LaunchCallMethod @@ -56,7 +56,7 @@ class Event { } public wait() { - await this.promise; + waitForCompletion(() => this.promise); } public fire() { @@ -146,7 +146,7 @@ async function asyncCallWithoutAwait(): Promise> { // recursive async functions function recursiveAsync(): boolean { let res : Promise> = asyncCallWithoutAwait(); - return await res; + return waitForCompletion(async(): Promise => await res); } function launchAsyncFunctions(): Promise { @@ -155,7 +155,7 @@ function launchAsyncFunctions(): Promise { function ACoroutineCallAsyncFunctions(): boolean { let res : Job> = launch, ()=>Promise>(launchAsyncFunctions) as Job> - return await res.Await(); + return waitForCompletion(() => res.Await()); } async function asyncFunctionLaunchCall() { @@ -164,7 +164,7 @@ async function asyncFunctionLaunchCall() { function asyncFunctionLaunchACoroutine(): boolean { let res : Promise> = asyncFunctionLaunchCall(); - return (await res).Await(); + return waitForCompletion>(() => res).Await(); } // oom -- Gitee