Merge branch 'dev' of gitcode.net:dcloud/hello-uts into dev

pages/SyntaxCase/index.uvue

@@ -53,7 +53,10 @@
         <view>测试callback：{{ format(testUtsClassInstanceResult['callback']) }}</view>
         <button @click="testUtsClassSetter">点击测试class 示例setter方法</button>
         <view>测试setter：{{ format(testUtsClassSetterResult) }}</view>
-        <button @click="testAll">点击测试所有</button>
+        <button @click="testAll">点击测试所有</button>
+        <!-- #ifdef APP-IOS -->
+        <button @click="testPromiseStaticMethod">点击测试promise静态方法</button>
+        <!-- #endif -->
       </view>
       <view style="height: 20px;"></view>
   </scroll-view>
@@ -73,6 +76,11 @@
         request,
         SetterTest,
     } from "../../uni_modules/uts-syntaxcase";
+    // #endif
+    // #ifdef APP-IOS
+    import {
+      testPromiseStaticMethod
+    } from "@/uni_modules/uts-syntaxcase"
     // #endif
     let test:Test|null = null
     let id = 0
@@ -441,7 +449,12 @@
               } catch (e) {
                     console.error("testUtsClassSetter", e);
               }
-            },
+            },
+            // #ifdef APP-IOS
+            testPromiseStaticMethod() {
+              testPromiseStaticMethod()
+            }
+            // #endif
         }
     }
 </script>
\ No newline at end of file

uni_modules/uts-syntaxcase/utssdk/index.uts

 import { RequestTask, SyncOptions, AsyncOptions, SyntaxResult, SyncResult, TestOptions } from "./interface.uts";
 import { log } from "./utils.uts";
 
+// #ifdef APP-IOS
+import { UTSPromiseAggregateError, UTSPromiseFulfilledResult, UTSPromiseRejectedResult} from "DCloudUTSFoundation";
+// #endif
 
 /**
  * 导出一个属性
@@ -121,6 +124,104 @@ export class Test {
   }
 }
 
+// #ifdef APP-IOS
+// #ifdef UNI-APP-X
+
+export function testPromiseStaticMethod() {
+	 let p0 = new Promise<SyntaxResult | null>((resolve, reject) => {
+		 let success = true
+		 setTimeout(() => {
+			 if (success) {
+			 	const res : SyntaxResult = {
+			 	  name: "pomise 0",
+			 	}
+			 	resolve(res);
+			 } else{
+			 	reject(new Error("this is promise 0 reject reasion"))
+			 }
+
+		 }, 1000);
+	 });
+	 
+	 let p1 = new Promise<SyntaxResult  | null>((resolve, reject) => {
+	 		 let success = true
+	 		 setTimeout(() => {
+	 			 if (success) {
+	 			 	resolve(null);
+	 			 } else{
+	 			 	reject(new Error("this is promise 1 reject reasion"))
+	 			 }
+	 
+	 		 }, 2000);
+	 });
+	 
+	 let p2 = new Promise<SyntaxResult | null>((resolve, reject) => {
+	 		 let success = false
+	 		 setTimeout(() => {
+	 			 if (success) {
+	 			 	resolve(null);
+	 			 } else{
+	 			 	// reject(new Error("this is promise 2 reject reasion"))
+					reject(null)
+	 			 }
+	 
+	 		 }, 2500);
+	 });
+	 
+	 // test for any
+	 let pt = Promise.any([p0, p1, p2]);
+	 pt.then( (res) => {
+		 console.log("promise.any test success", res)
+	 })
+	 .catch( (error: any | null) => {
+		 if (error instanceof UTSPromiseAggregateError) {
+		 	let err = error as UTSPromiseAggregateError
+			console.log(err.name, err.message, err.errors);
+		 }else {
+			 console.log(error);
+		 }
+	 })
+	 
+	 // test for allSettled
+	 Promise.allSettled([p0, p1, p2])
+	 .then((res) => {
+		 res.forEach((item, index) => {
+			 if (item instanceof UTSPromiseFulfilledResult<SyntaxResult  | null >) {
+			 	let item0 = item as UTSPromiseFulfilledResult
+				console.log(item0.value, "UTSPromiseFulfilledResult value")
+			 } else if (item instanceof UTSPromiseRejectedResult<SyntaxResult | null>) {
+			 	let item0 = item as UTSPromiseRejectedResult
+			 	console.log(item0.reason, "UTSPromiseRejectedResult reason")
+			 }
+		 })
+	 })
+	 .catch((error:  any | null) => {   
+		 console.log(error, "rejected test for promise.allSettled")
+	 })
+	 
+	 // test for all 
+	 Promise.all([p0, p1, p2])
+	 .then((res)=> {
+		 console.log(res, res.count)
+	 })
+	 .catch( (error: any | null) => {
+		 console.log(error, "rejected test for promise.all")
+	 })
+	 
+	 // test for race
+	 Promise.race([p0, p1, p2])
+	 .then((res) => {
+		 console.log(res, "resolved test for promise.race");
+	 })
+	 .catch((error: any | null) => {
+		 console.log(error, "catch test for promise.race")
+	 })
+}
+
+
+// #endif
+// #endif
+
 export class SetterTest {
   
   private _nickName: string = '';

uni_modules/uts-tests/utssdk/Promise.uts

+import { describe, test, expect, Result } from './tests.uts'
+
+export function testPromise(): Result {
+    return describe("Promise", () => {
+        // #ifdef APP-IOS
+        test('constructor', () => {
+          // 常规方式
+           let p = new Promise<Int>((resolve, reject) => {
+             let success = true;
+              setTimeout(()=>{
+                if (success) {
+                  resolve(2024)
+                } else{
+                  let error = new Error("something going wrong")
+                  reject(error)
+                }
+              }, 10);
+           });
+           p.then((res: Int) => {  
+              expect(res).toEqual(2024) 
+           })
+           
+           // 单个函数
+           let p1 = new Promise<any | null>((resolve: (value: any | null) => void) => {
+             setTimeout(function() {
+               resolve(null)
+             }, 10);
+           })
+           p1.then((res: any | null) => {
+              expect(res).toEqual(null) 
+           })
+           
+           // 指定函数类型
+           let p2 = new Promise((resolve: (value: string) => void, reject: (error: any | null) => void) => {
+              setTimeout(function() {
+                reject(null)
+              }, 10);
+           })
+           p2.then()
+           .catch((error: any | null) => {
+             expect(error).toEqual(null) 
+           })
+        })
+        
+        test('then', () => {
+            let p = new Promise<string>((reslove, reject) => {
+            	setTimeout(function() {
+                reslove("hello world")  
+            	}, 13);
+            })
+              
+            p.then(
+            	(res: string): Promise<string> => {
+                expect(res).toEqual("hello world") 
+            		let p0 = new Promise<string>((reslove,reject) => {
+            			var success = true;  
+            			setTimeout(function() {
+            				success = true;
+            				if (success) {
+            					reslove(res + " 2024")  
+            				} else{
+            					reject("first then p0 reject message")
+            				}
+            			}, 8);
+            		})
+            		return p0;
+            	},
+            	(err: any | null): void => {  
+            		throw new Error("first then throw error")
+            	}
+            )
+            .catch(
+            	(err):string => {
+            		return "first catch return message"
+            	}
+            )   
+            .then(
+            	(res) => {
+                console.log(res)
+                expect(res).toEqual("hello world 2024") 
+            	}
+            )
+            .catch(
+            	(err) => {
+            		console.log(err, "this is seconded catch")
+            	}
+            )  
+            .finally(() => {
+              console.log("finally")
+              expect("finally").toEqual("finally")
+            })
+        })
+        
+        test('catch', () => {
+        
+        })
+        
+        test('finally', () => {
+            Promise.resolve(2)
+            .finally(() => {
+              console.log("finally")
+            })
+            .then((res) => {
+              expect(res).toEqual(2)
+            })
+            
+            Promise.reject(3)
+            .finally(() => {
+              console.log("finally")
+            })
+            .catch((res) => {
+              expect(res).toEqual(3)
+            })
+        })
+        
+        test('resolve', () => {
+          // resolve array
+          Promise.resolve([1,2,3])
+          .then((res) => {
+            expect(res).toEqual([1,2,3])
+          })
+          
+          // resolve string
+          Promise.resolve("成功")
+          .then((res) => {
+            expect(res).toEqual("成功");
+          })
+          
+          // resolve null
+          Promise.resolve()
+          .then((res) => {
+            // expect(res).toEqual(null);
+          })
+          
+          // resolve promise
+          const original = Promise.resolve(33)
+          const cast = Promise.resolve(original)
+          cast.then((res) => {
+            expect(res).toEqual(33);
+          })
+          // 注：此处飘红是编译器误报，实际可以判等
+          expect(original === cast).toEqual(true)
+        })
+        
+        test('reject', () => {
+          // reject array
+          Promise.reject([1,2,3])
+          .catch((err) => {
+            expect(err).toEqual([1,2,3])
+          })
+          
+          // reject error
+          Promise.reject(new Error("this is reject error message"))
+          .catch((err) => {
+            expect((err as Error).message).toEqual("this is reject error message");
+          })
+          
+          // reject null
+          Promise.reject()
+          .catch((err) => {
+            expect(err).toEqual(null);
+          })
+          
+          // reject promise
+          const original = Promise.reject(33)
+          const cast = Promise.reject(original)
+          cast.catch((err) => {
+            expect((err as Promise<any>) === original).toEqual(true);
+          })
+          expect(original === cast).toEqual(false)
+          
+        })
+        
+        test('all', () => {
+           let p0 = new Promise<string>((resolve, reject) => {
+             setTimeout(function() {
+               resolve("1");
+             }, 10);
+           })
+           
+           let p1 = new Promise<string>((resolve, reject) => {
+             setTimeout(function() {
+               resolve("2");
+             }, 10);
+           })
+           
+           let p2 = new Promise<string>((resolve, reject) => {
+             setTimeout(function() {
+               resolve("3");
+             }, 10);
+           })
+           
+           let p3 = new Promise<string>((resolve, reject) => {
+             setTimeout(function() {
+               let error = new Error("p3 reject reason")
+               reject(error);
+             }, 10);
+           })
+           // resolve
+           Promise.all([p0, p1, p2])
+           .then((res) => {
+             console.log(res);
+             expect(res).toEqual(["1", "2", "3"]) 
+           })
+           
+           // reject
+           Promise.all([p1, p2, p3])
+           .then()
+           .catch((error) => {
+             console.log(error);
+             expect((error as Error).message).toEqual("p3 reject reason");
+           })
+        })
+        
+        test('allSettled', () => {
+            let p0 = new Promise<string | null>((resolve, reject) => {
+              setTimeout(function() {
+                resolve("1");
+              }, 10);
+            })
+            
+            let p1 = new Promise<string | null>((resolve, reject) => {
+              setTimeout(function() {
+                resolve(null);
+              }, 10);
+            })
+            
+            let p2 = new Promise<string | null>((resolve, reject) => {
+              setTimeout(function() {
+                reject(null)
+              }, 10);
+            })
+            
+            let p3 = new Promise<string  | null>((resolve, reject) => {
+              setTimeout(function() {
+                let error = new Error("p3 reject reason")
+                reject(error);
+              }, 10);
+            })
+            
+            Promise.allSettled([p0, p1, p2, p3])
+            .then((res) => {
+              console.log(res);
+              let statusArr : string[] = []
+              res.forEach((item, index) => {
+                statusArr.append(item.status)
+              })
+              expect(statusArr).toEqual(["fulfilled", "fulfilled", "rejected", "rejected"]) 
+            })
+        })
+        
+        test('any', () => {
+          let p0 = new Promise<string | null>((resolve, reject) => {
+            setTimeout(function() {
+              resolve("1");
+            }, 10);
+          })
+          
+          let p1 = new Promise<string | null>((resolve, reject) => {
+            setTimeout(function() {
+              resolve(null);
+            }, 15);
+          })
+          
+          let p2 = new Promise<string | null>((resolve, reject) => {
+            setTimeout(function() {
+              reject(null)
+            }, 10);
+          })
+          
+          let p3 = new Promise<string  | null>((resolve, reject) => {
+            setTimeout(function() {
+             reject("error");
+            }, 12);
+          })
+          
+          // test for resolve
+          Promise.any([p0, p1, p2])
+          .then((res) => {
+            console.log(res)
+            expect(res).toEqual("1");
+          })
+          
+          // test for reject
+          Promise.any([p2, p3])
+          .then()
+          .catch(
+            (error: any | null) => {
+              console.log("test for promise.any error ==> ", error);
+              expect((error as UTSPromiseAggregateError).name).toEqual("AggregateError");
+              expect((error as UTSPromiseAggregateError).message).toEqual("All promises were rejected");
+              expect((error as UTSPromiseAggregateError).errors).toEqual([null, "error"]);
+          })   
+        })
+        
+        test('race', () => {
+          let p0 = new Promise<string | null>((resolve, reject) => {
+            setTimeout(function() {
+              resolve("fast");
+            }, 10);
+          })
+          
+          let p1 = new Promise<string | null>((resolve, reject) => {
+            setTimeout(function() {
+              resolve("slow");
+            }, 15);
+          })
+          
+          let p2 = new Promise<string | null>((resolve, reject) => {
+            setTimeout(function() {
+              reject(null)
+            }, 12);
+          })
+          
+          // test for resolve
+          Promise.race([p0, p1])
+          .then((res) => {
+            console.log("test for race resolve ===> ", res);
+            expect(res).toEqual("fast");
+          })
+          
+          // test for reject 
+          Promise.race([p1, p2])
+          .then()
+          .catch((error) => {
+            console.log("test for race reject ===> ", error);
+            expect(error).toEqual(null);
+          })
+        })
+        // #endif
+    })
+}

uni_modules/uts-tests/utssdk/index.uts

@@ -19,9 +19,9 @@ import { testType } from './Type.uts'
 export { Result } from './tests.uts'
 import { testArrayBuffer } from './ArrayBuffer.uts'
 import { testNativeCode } from './NativeCode.uts'
+import { testPromise} from "./Promise.uts"
 
-
-// Promise、Proxy、Reflect、Weakmap、WeakSet 不支持
+// Proxy、Reflect、Weakmap、WeakSet 不支持
 export function runTests() : UTSJSONObject {
   const ArrayRes = testArray();
   const DateRes = testDate();
@@ -40,12 +40,16 @@ export function runTests() : UTSJSONObject {
   const TypeRes = testType();
   const JSONLargeRes = testJSONLarge();
   const consoleRes = testConsole();
-  const UTSJSONObjectRes = testUTSJSONObject();
+  const UTSJSONObjectRes = testUTSJSONObject();
 
   // #ifdef  APP-ANDROID || WEB
   const ArrayBufferRes = testArrayBuffer();
   // #endif
-  const NativeCodeRes = testNativeCode();
+  const NativeCodeRes = testNativeCode();
+  
+  // #ifdef APP-IOS
+   const PromiseRes = testPromise();
+  // #endif
   return {
     Array: ArrayRes,
     Date: DateRes,
@@ -68,6 +72,9 @@ export function runTests() : UTSJSONObject {
     // #ifdef  APP-ANDROID || WEB
     ArrayBuffer: ArrayBufferRes,
     // #endif
-    NativeCode: NativeCodeRes
+    NativeCode: NativeCodeRes,
+    // #ifdef APP-IOS
+    Primise: PromiseRes
+    // #endif
   }
 }
\ No newline at end of file