1/* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16const INCREMENT = 5; 17const EXPECTED_VALUE = 42; 18 19let counter = 0; 20 21function clearCounter() { 22 counter = 0; 23} 24 25function foo(): number { 26 return EXPECTED_VALUE; 27} 28 29async function fooAsync(): Promise<number> { 30 return foo(); 31} 32 33function add(num: int) { 34 counter += num; 35} 36 37async function addAsync(num: number) { 38 await Promise.resolve('a'); 39 counter += num; 40} 41 42function throwLaunchError() { 43 throw new Error(); 44} 45 46async function throwAsyncError(): Promise<void> { 47 throw new Error(); 48} 49 50function testFooLaunch(): number { 51 let job : Job<number> = launch<number, ()=>number>(foo); 52 let result = job.Await(); 53 54 return result; 55} 56 57function testAddSchedule(): void { 58 clearCounter(); 59 let job: Job<void> = launch<void, (num: int)=>void>(add, INCREMENT); 60 61 Coroutine.Schedule(); 62} 63 64function recursiveFoo(): Job<number> { 65 let job: Job<number> = launch<number, ()=>number>(testFooLaunch); 66 67 return job; 68} 69 70function testRecursiveLaunch(): number { 71 let job: Job<Job<number>> = launch<Job<number>, ()=>Job<number>>(recursiveFoo); 72 let result = job.Await().Await(); 73 74 return result; 75} 76 77function testLaunchThrow(): boolean { 78 try { 79 let job: Job<void> = launch<void, ()=>void>(throwLaunchError); 80 job.Await(); 81 } catch (e) { 82 return e instanceof Error; 83 } 84 85 return false; 86} 87 88function testFooAsync(): number { 89 let p: Promise<number> = fooAsync(); 90 let result = await p; 91 92 return result as number; 93} 94 95function testAddAsyncSchedule(): void { 96 clearCounter(); 97 98 addAsync(INCREMENT); 99 Coroutine.Schedule(); 100} 101 102async function recursiveAsyncFoo(): Promise<Promise<number>> { 103 return fooAsync(); 104} 105 106function testRecursiveAsync(): number { 107 let p: Promise<Promise<number>> = recursiveAsyncFoo(); 108 109 return await p; 110} 111 112function testAsyncThrow(): boolean { 113 try { 114 let p: Promise<void> = throwAsyncError(); 115 await p; 116 } catch (e) { 117 return e instanceof Error; 118 } 119 120 return false; 121} 122 123function testACoroutineEaworker(): void { 124 let ew = new EAWorker(); 125 126 let job0 = ew.run<number>(testFooLaunch); 127 let job1 = ew.run<void>(testAddSchedule); 128 let job2 = ew.run<number>(testRecursiveLaunch); 129 let job3 = ew.run<boolean>(testLaunchThrow); 130 131 assertEQ(EXPECTED_VALUE, job0.Await()); 132 job1.Await(); 133 assertEQ(counter, INCREMENT); 134 assertEQ(EXPECTED_VALUE, job2.Await()); 135 assertTrue(job3.Await()); 136 137 ew.join(); 138} 139 140function testAJCoroutineEaworker(): void { 141 let ew = new EAWorker(); 142 143 let job0 = ew.run<number>(testFooAsync); 144 let job1 = ew.run<void>(testAddAsyncSchedule); 145 let job2 = ew.run<number>(testRecursiveAsync); 146 let job3 = ew.run<boolean>(testLaunchThrow); 147 148 assertEQ(EXPECTED_VALUE, job0.Await()); 149 job1.Await(); 150 assertEQ(counter, INCREMENT); 151 assertEQ(EXPECTED_VALUE, job2.Await()); 152 assertTrue(job3.Await()); 153 154 ew.join(); 155} 156 157function testACAJcoroutine(): void { 158 let ew = new EAWorker(); 159 let job1 = ew.run<number>(testFooLaunch); 160 let job2 = ew.run<number>(testFooAsync); 161 162 let res1 = job1.Await(); 163 let res2 = job2.Await(); 164 165 ew.join(); 166 167 assertEQ(res1, res2); 168} 169 170function testACoroutineCallAJCoroutine(): void { 171 let ew = new EAWorker(); 172 let job1 = ew.run<number>(() => { 173 let job2: Job<Promise<number>> = launch<Promise<number>, ()=>Promise<number>>(fooAsync) 174 let p = job2.Await(); 175 let result = await p; 176 177 return result; 178 }); 179 180 ew.join(); 181 182 assertEQ(EXPECTED_VALUE, job1.Await()); 183} 184 185async function AsyncCallLaunch(): Promise<Job<number>> { 186 let job: Job<number> = launch<number, ()=>number>(foo); 187 188 return job; 189} 190 191function testAJCoroutineCallACoroutine(): void { 192 let ew = new EAWorker(); 193 let job1 = ew.run<Promise<Job<number>>>(AsyncCallLaunch); 194 let p = job1.Await(); 195 let job2: Job<number> = await p; 196 let result = job2.Await(); 197 ew.join(); 198 199 assertEQ(EXPECTED_VALUE, result); 200} 201 202function testNestedEAWorker(): void { 203 clearCounter(); 204 205 let e1 = new EAWorker(); 206 let job1 = e1.run<number>(():number => { 207 let e2 = new EAWorker(); 208 let job2 = e2.run<number>(():number => { 209 return foo(); 210 }); 211 e2.join(); 212 213 return job2.Await(); 214 }); 215 let result = job1.Await(); 216 217 e1.join(); 218 219 assertEQ(EXPECTED_VALUE, result); 220} 221 222function main(): int { 223 const suite = new ArkTestsuite('EAWorker Test Suite'); 224 225 suite.addTest('testACoroutineEaworker', testACoroutineEaworker); 226 suite.addTest('testAJCoroutineEaworker', testAJCoroutineEaworker); 227 suite.addTest('testACAJcoroutine', testACAJcoroutine); 228 suite.addTest('testACoroutineCallAJCoroutine', testACoroutineCallAJCoroutine); 229 suite.addTest('testAJCoroutineCallACoroutine', testAJCoroutineCallACoroutine); 230 suite.addTest('testNestedEAWorker', testNestedEAWorker); 231 232 return suite.run(); 233} 234