1/* 2 * Copyright (c) 2024 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 */ 15import assert from 'assert'; 16 17export type callback<T> = () => T; 18export type CallbackArray<T extends callback<T>> = () => T; 19type t = () => t; 20let a: CallbackArray<() => t>; 21a = () => a; 22assert(a() === a); 23 24let var1: number = 1; 25typeof var1; 26type t01 = typeof var1; 27let a2: t01 = 1; 28assert(a2 === 1); 29 30let c: [string, number, boolean] = ["", 1, false]; 31assert(c[0] === ""); 32assert(c[1] === 1); 33assert(c[2] === false); 34 35type a = [number, string, ...number[]]; 36 37let temp1: number | string = 1; 38assert(temp1 === 1); 39let temp2: number & (string | number) = 1; 40assert(temp2 === 1); 41type temp7 = number; 42type temp8 = string; 43function foo<T>(param: T extends temp7 ? temp7 : temp8) { 44 return param; 45} 46assert(foo<number>(1) === 1); 47 48type X2<T> = T extends { a: infer U; b: infer U } ? U : never; 49let x: X2<{ a: number; b: number }> = 1; 50assert(x === 1); 51 52let temp6: (string | number)[] = [1, 2]; 53assert(temp6[0] === 1); 54assert(temp6[1] === 2); 55 56interface Person { 57 name: string; 58 age: number; 59} 60type PersonKeys = keyof Person; 61let b: PersonKeys = "name"; 62assert(b === "name"); 63 64type Foo<T extends any[]> = { 65 [P in keyof T]: T[P]; 66}; 67let d: Foo<number[]> = [1]; 68assert(d[0] === 1); 69 70let temp3: "cc" = "cc"; 71assert(temp3 === "cc"); 72let temp4: [prop1: string, prop2: number] = ["1", 2]; 73assert(temp4[0] === "1"); 74assert(temp4[1] === 2); 75 76type T2 = { 77 description: string; 78 f1(para1: number): boolean; 79 (para2: number): number; 80}; 81const temp9: T2 = (para3: number) => para3; 82temp9.description = "test"; 83temp9.f1 = (para4: number) => { 84 return para4 > 0 ? true : false; 85}; 86assert(temp9(100) === 100); 87assert(temp9.description === "test"); 88assert(temp9.f1(-100) === false); 89 90type T3 = (para5: number) => number; 91const temp10: T3 = (para6: number) => para6; 92assert(temp10(200) === 200); 93 94// Different grammar scenarios of indexedAccessType 95type T4 = { 96 U: number; 97 V: string; 98 W: boolean; 99}; 100export type T5 = { X1: T4 }; 101 102let temp5: T5["X1"]["U"] = 2; 103assert(temp5 === 2); 104 105let temp11: T4["U"] = 3; 106let temp12: T4["V"] = "test"; 107let temp13: T4["W"] = false; 108assert(temp11 === 3); 109assert(temp12 === "test"); 110assert(temp13 === false); 111 112let temp14: T4["U" | "V"] = 4; 113let temp15: T4["U" | "V"] = "test"; 114assert(temp14 === 4); 115assert(temp15 === "test"); 116 117let temp16: T5["X1"]["U" | "V"] = 5; 118let temp17: T5["X1"]["U" | "V"] = "test"; 119assert(temp16 === 5); 120assert(temp17 === "test"); 121 122let temp18: T4[keyof T5["X1"]] = 6; 123assert(temp18 === 6); 124 125const MyArray = [ 126 { n1: "Alice", m1: 15 }, 127 { n1: "Bob", m1: 23 }, 128 { n1: "Eve", m1: 38 }, 129]; 130type A1 = (typeof MyArray)[1]["m1"]; 131let temp19: A1 = 7; 132assert(temp19 === 7); 133 134type Tuple = [string, number]; 135let temp20: Tuple[0] = "test"; 136let temp21: Tuple[1] = 9; 137assert(temp20 === "test"); 138assert(temp21 === 9); 139 140// Defination of unionType 141type U1 = "123" | "321"; 142type U2 = 1234 | 4321; 143type U3 = "3124" | 4123; 144type U4 = "U1234" | 2143; 145type U5 = "U4213" | "U4132"; 146type U6 = "U3412" | "3421"; 147 148// need to add "1234" into whitelist when enable prop+strProp 149let temp22: U1["1234"] = "1"; 150assert(temp22 === "1"); 151let temp23: U1[4321] = "2"; 152assert(temp23 === "2"); 153let temp24: U5[4321] = "3"; 154assert(temp24 === "3"); 155let temp25: U5["1234"] = "4"; 156assert(temp25 === "4"); 157let temp26: U6[4321] = "5"; 158assert(temp26 === "5"); 159let temp27: U6["1234"] = "6"; 160assert(temp27 === "6"); 161 162// Define properties in type individually 163type nType1 = { 164 prop3: number; 165 prop4: number; 166 "3214": number; 167 1324: number; 168 [2143]: number; 169 ["2314"]: number; 170}; 171 172// Define properties in type and access them using indexedAccessType 173type nType2 = { 174 prop5: number; 175 prop6: number; 176 "3412": number; 177 ["2341"]: number; 178 1432: number; 179 [1423]: number; 180 181 // need to add into whitelist when enable prop and prop+strProp 182 1243: number; 183 [2134]: number; 184 185 // need to add into whitelist when enable prop+strProp 186 "3142": number; 187 ["2314"]: number; 188}; 189 190let temp28: nType2["prop5"] = 1; 191assert(temp28 === 1); 192let temp29: nType2["prop6"] = 2; 193assert(temp29 === 2); 194let temp30: nType2["3412"] = 3; 195assert(temp30 === 3); 196let temp31: nType2["2341"] = 4; 197assert(temp31 === 4); 198let temp32: nType2["1432"] = 5; 199assert(temp32 === 5); 200let temp33: nType2["1423"] = 6; 201assert(temp33 === 6); 202 203// need to add into whitelist when enable prop and prop+strProp 204let temp34: nType2[1243] = 7; 205assert(temp34 === 7); 206let temp35: nType2[2134] = 7; 207assert(temp35 === 7); 208 209// need to add into whitelist when enable prop+strProp 210let temp36: nType2[3142] = 8; 211assert(temp36 === 8); 212let temp37: nType2[2314] = 9; 213assert(temp37 === 9); 214