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 bf5d65dc5bc1095993bd91ff7faddaf1af3074c1..b35cf776350c089247287ac6f38ab5453bda892b 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 382a15046cb9a0108f58b13aea55dc2cc86003e7..2a185fef54be0c29a9d1863bc9b2490120b91132 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 325c903d5c9242ef2158ee98a8b66edc22639e87..ad1fbde475556772f1c51819d86bdba66a68c357 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 9703bbc93ace97a44cb49b36c4bf66eceffa9e2d..02e0e30ba7afaf5c0c85f6ff0d1ebf1fa96690d8 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 c3997cfd9178a6e6496653b6ac1ae84e8d158386..d2079dabd8203d8a27be183c4c30092813da4cd0 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 804d9555192e41bf279f719f05a6155072d2b705..9190c8cb29d232a44fdef2dd93a0a7bce2bf73cb 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 21276bc69b8f7e836150c450521969703ce5c495..19ee73ade2e4f995c7fb13eca1fa6d4cee4ede51 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 ccba65e074df48f0706e974b74a5250618b564f2..4d044796fdd011c70ab59fec20a84d7a653532c0 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 d29d3f3884c7bf2661026437bd86f9aacd24e895..af5120a0408a5d9be8497e44d62e3fd84284b1e2 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 01ee4d0c88be87990cb676ab2a25097f9fb58a8f..1aa7276fd95db812a9dee3ceea06788953fd0c4e 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 b349a0ef797551ee6fb95a95dd4bcf97e77ea2ee..9ddf9dd843d89066d7ec346c9dd03ff74ce24696 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 a6bf503ddee913d433cdfc3faba6fc54109c814d..806ecfb1e13759c64b35e32a8abb0079740fc514 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 205248b0a03dd6b1b6d9a0172dc28fd973ccd072..fcfd735810ab5cbd306b76ca692f11a137b0a468 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 f443845f0ce25ade2ef285ca2a23af61b9ae4fc3..237744b2f779404c2161f557108fa9487d31509c 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 f482dc67922468d367c361a62e563533d2649a33..0b55da7eed84f998badbcc498c1b55cb261ae9ad 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 a4b3a1fcc16de1accd5e031dc7658b0e359500e3..9d1bcec587da4269b9a7c49c911ebebd207f319a 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 d59bf73bac9a028150d9effb505e332f57755810..3514079fd0a49f6dafecd5bf3428918f22328767 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 2e832a2262b141c4df75430fa99424f52b5c7cdc..1e883c849eb8ff3f30dc70c526fcc04e82fcae4f 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 fcbd74758cbf2635472352216b8ad755f85d9c2d..21e77e7f54b189d6bd3d88b2029bf29d356a5b90 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 93351a765aa69abb7ea42674cdfa94a2129f8f5e..b3b3e4344270de29705132a4f89a6e0e4aa36651 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 56d7a85cbeb5b83500c6e6a5484cf01cd2c160be..260878afa820d88b9b459d081af879b319d2719d 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 31cbafe3449340962ecf9e98105b5b4018d2ada2..9f0b981fd6bcc66edb69f624c47a77ee15943995 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 cf5a485cd9145f68f220fcc936f72e577275818c..2c468085faf446c0274a3817b92cb1582a35394b 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 65c784218271a4f722e31ea8bb624e469c90ff8c..8e7ae6ab7c0734e7ae8f751cc945996c326ccf21 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 8d1ca795e492577319d9615a31a46a219a7612d2..f56f89a6d2b0887f4e994a9bb041429ae6373980 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 76e83f1a19f2ebc48ea5f81d6ead41eb459995ca..a29e2914e02218379204098e3f4c44bbaf7c85b1 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 940f2e0e89ea3dbb5c0bd4796282b4ade5a4780e..f67debb6cac2a7508bbd1b8b366f3315ae73d9f0 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 5852ba8efab20915c3a9684c14b1fc97ff5960a4..e50b1f105b5f8eb0c65710312c8eebbc3f3de90f 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 ff18cad4d91b1b2fd81a1e0098c5a229cc90b649..f1675f95bc1db6b3c018db89b02df1fcd738595c 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 c598f19e29493a7bdbb025a07e504d37422190cb..87f87fb2746832608dcb3fb75c0d0c65126a8558 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 80061193e9c87ce54c134cdd841895c298b3f372..84ae48209eb4ba4a36e6e09f46d4442cab12c846 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 114c2e8e894b1c87984114fd0ae6e8f5185687c9..54d167391f4a51e383f6bbc80d1a9d335159d5e5 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 595ea295c35658cc939a309e8fe53682913be452..14612eb8552cc4e6bc69e1c18657aaa26b29a0ce 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 496bd1170ef493f6676cbb2b50bccf00f021d764..1fd7fe00f540e34fe4ebc94073733d1aa9b701ec 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 fa9f399829be3e90a07d6e0d39204726da415a77..07ec5e9e54c3087850f08e9e9453ca7a2c78e15e 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 e2d9dbd45a416674d76e52fbe0da9726cd4d58cc..834a176d5b2c7ecdeea8d482fca0cf383f5af435 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 5a2123a9ef826ba1f340c4e17524ad2a24fcadae..13e4eab67c61184076bd6ce581ece333fdf58cf6 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 ea2897e74cb865882748fb66299e675fcef29302..8d3af9dc0ff047d08abd231803d8e7d938a71ec2 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 8a357d502b439daea8b3f14158e2122793011053..9ef82a85db5a13dc0fd67b3b76225b06b295cf61 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 a04b0113c0dd6a10af0a7f705c0817c6a7025ff4..f4e996c22011a32ee084273c9f46fcf754de7a3e 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 f714f812d9965b88b1d4bfd9a76e0d3766388165..72093e3b1d8318de77a9a4564eca50fcdb906c85 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 3901919f017fd6277cb8ee042f83ef0a8886ad8e..bdcacb009e5cf957f82a8a835f4bbba45853d938 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 5f20a63c3cb2e71aa254014ea668488f54464e1f..cfc6ae11e5cbd4cfe9b83a1740eab53038819d88 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 13f116275f7323f4a88ff9b9e2872151f16514ca..6ff7239b5ed3e460dfa0da8efe6c3fac53949027 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 5529365fdc9dd2f37069f9d7c795557235ef6703..19d1c21edb699ae2ce9de80807adea2b04f6078d 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 c8617e7af72b541dfc829d865bde966ceddec262..2e3d92adc852506856ea5b9735d2e03b009c5b4d 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 bdabe2f5745ec6602f9c861adaf83b28d120973d..49bb2869e6dc3eb8c0ae22534e772a13ac90e42d 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 0bb6a6f3c7d74b43ee773cad288b0492eef60ae5..bdb1cea271547ccda814c3fa822bd061733b1aa2 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 d0147795c4cce3e3a79304c2c1d9dea92f585bcf..33a5dcf07771aab9d3f87afff1983fc7523dcf72 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 ce815a5b598584b3ee9893ec382557f8633de689..6c7547eb102b1a65abaaf792324141bdcbdbdf35 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 2fa6385b1f538fc97e6d02bf48925ca023e09671..6ba94db27b4aedb987acee57eba3ba0ad2b928cb 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 fd7ff3875499347c41f127705a5afc68b3bf2161..e2176f1ce876a5a8d170ad9bfa1b75b1a9bc73b7 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 32c0d3c7b75a6418e1288d95c6246b5f184cd753..9efb2a09a56dda2ddf613070362c889d3c12aebb 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 008d9cc5328ba0393c1a583f56df9d2a3d1cf42a..a7eae823919ffb4701107278285d18b2b34c3986 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 aae251d6ffbe436afd68d3753643686578170078..c6d950e9996b79ec4d5bf2a06ac85ff077f65826 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 6ff4c5dbae18a9c534991c8e73cc77cbce0bdb7b..4fe7d6a5099c4b69401596e9147c46f9c58a150a 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 7c5f45edc0a6931543d2eb08ec2d54c356307b57..cce4bc3f48f29bfad89b4e41df2064c74f84aaa6 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 9cee00ad6eb94ab0bd2d1cc91d4a2a771d86a558..81ed9b42f00be4390fa054441b7dd8eb843c990b 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 3310963a9170eb972893e6b82fdfb2ac7457e9ca..732fda293f16df5a8bf38834e3c621371d476556 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 f19c79ee29c4b0cc2905b8d59ff3c72461a40ce9..332ea613a9280aa359374813ad46764a6a3b87b3 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 fe703237cb90fd22acda6195ad89cb2c85dee9d0..fad24567a78af4a768019ee118c3345c4df5beb0 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 3c3a9f2a1dfbba27296030a881e8bd364ab6195e..ece622e9ae31d4f6189d0b3910a7781edeca25a1 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 47cbcf5258de87345f360d638981e7828fad86a6..66b016050191568f184aaf2a79914bd57e13ad17 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 a75ba523308a505295249644590731397616a44c..13f9b9cfbf1fcdcfbb947b69d99ba12997611ffb 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 52677346438570bf49cfb76440c15e3caecf1653..7351333bc065b4ef2d98e30bbbc559074b205502 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 54c025f8fddfb255102ea05edcbd11bf073b6e39..06974696099e1ec4063a887e0f18e5cff434a246 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 c28dd15409e99f2bd0ec22dc79945871ec04f72f..624d37d601210e10a3e29df279ecd2a5a5b3390c 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