• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 */
15import * as SceneTest from "scene";
16import * as SceneNodeTest from "sceneNodeParameters";
17import {BusinessError} from "@ohos.base";
18
19loadLibrary("ani_graphics3d");
20
21let sResFactory: SceneTest.SceneResourceFactory = SceneTest.getSceneResourceFactory();
22let sNodePara: SceneNodeTest.SceneNodeParameters = SceneNodeTest.getSceneNodeParameters();
23let sResPara: SceneTest.SceneResourceParameters = SceneTest.getSceneResourceParameters();
24function test_ani_graphics3d_scene_createCamera() {
25    let param = sNodePara;
26    let info = SceneTest.getCamera();
27    let err: BusinessError = new BusinessError();
28    try {
29        info = sResFactory.createCameraPro(param);
30    } catch (e) {
31        err = e as BusinessError;
32    }
33
34    console.log("createCamera is: " + info.fov);
35    assertEQ(info.fov, 5.24 as float);
36}
37
38function test_ani_graphics3d_scene_createCamera_promise() {
39    let param = sNodePara;
40    let info = SceneTest.getCamera();
41    let err: BusinessError = new BusinessError();
42    try {
43        info = await sResFactory.createCamera(param);
44    } catch (e) {
45        err = e as BusinessError;
46    }
47
48    console.log("createCamera is: " + info.fov);
49    assertEQ(info.fov, 5.24 as float);
50}
51
52function test_ani_graphics3d_scene_createCamera_sync() {
53    let param = sNodePara
54    let promise = new Promise<SceneTest.Camera>((resolve, reject) => {
55        sResFactory.createCamera(param, (err: BusinessError, data: SceneTest.Camera) => {
56            if (err.code !== 0) {
57                reject(err);
58            } else {
59                resolve(data);
60            }
61        });
62    });
63
64    let info = SceneTest.getCamera();
65    let err: BusinessError = new BusinessError();
66    try {
67        info = await promise;
68    } catch (e) {
69        err = e as BusinessError;
70    }
71
72    console.log("createCamera is: " + info.fov);
73    assertEQ(info.fov, 5.24 as float);
74}
75
76function test_ani_graphics3d_scene_createLight() {
77    let param = sNodePara;
78    let lightType = SceneTest.LightType.SPOT;
79    let info = SceneTest.getLight();
80    let err: BusinessError = new BusinessError();
81    try {
82        info = sResFactory.createLightPro(param, lightType);
83    } catch (e) {
84        err = e as BusinessError;
85    }
86
87    console.log("createLightPro is: " + info.intensity);
88    assertEQ(info.intensity, 5.24 as float);
89}
90
91function test_ani_graphics3d_scene_createLight_promise() {
92    let param = sNodePara;
93    let lightType = SceneTest.LightType.SPOT;
94    let info = SceneTest.getLight();
95    let err: BusinessError = new BusinessError();
96    try {
97        info = await sResFactory.createLight(param, lightType);
98    } catch (e) {
99        err = e as BusinessError;
100    }
101
102    console.log("createLightPro is: " + info.intensity);
103    assertEQ(info.intensity, 5.24 as float);
104}
105
106function test_ani_graphics3d_scene_createLight_sync() {
107    let param = sNodePara;
108    let lightType = SceneTest.LightType.SPOT;
109    let promise = new Promise<SceneTest.Light>((resolve, reject) => {
110        sResFactory.createLight(param, lightType, (err: BusinessError, data: SceneTest.Light) => {
111            if (err.code !== 0) {
112                reject(err);
113            } else {
114                resolve(data);
115            }
116        });
117    });
118
119    let info = SceneTest.getLight();
120    let err: BusinessError = new BusinessError();
121    try {
122        info = await promise;
123    } catch (e) {
124        err = e as BusinessError;
125    }
126
127    console.log("createLightPro is: " + info.intensity);
128    assertEQ(info.intensity, 5.24 as float);
129}
130
131function test_ani_graphics3d_scene_createNode() {
132    let param = sNodePara;
133    let info = SceneTest.getNode();
134    let err: BusinessError = new BusinessError();
135    try {
136        info = sResFactory.createNodePro(param);
137    } catch (e) {
138        err = e as BusinessError;
139    }
140
141    console.log("createNode is: " + info.visible);
142    assertEQ(info.visible, true);
143}
144
145function test_ani_graphics3d_scene_createNode_promise() {
146    let param = sNodePara;
147    let info = SceneTest.getNode();
148    let err: BusinessError = new BusinessError();
149    try {
150        info = await sResFactory.createNode(param);
151    } catch (e) {
152        err = e as BusinessError;
153    }
154
155    console.log("createNode is: " + info.visible);
156    assertEQ(info.visible, true);
157}
158
159function test_ani_graphics3d_scene_createNode_sync() {
160    let param = sNodePara;
161    let promise = new Promise<SceneTest.Node>((resolve, reject) => {
162        sResFactory.createNode(param, (err: BusinessError, data: SceneTest.Node) => {
163            if (err.code !== 0) {
164                reject(err);
165            } else {
166                resolve(data);
167            }
168        });
169    });
170
171    let info = SceneTest.getNode();
172    let err: BusinessError = new BusinessError();
173    try {
174        info = await promise;
175    } catch (e) {
176        err = e as BusinessError;
177    }
178
179    console.log("createNode is: " + info.visible);
180    assertEQ(info.visible, true);
181}
182
183function test_ani_graphics3d_scene_createMaterial() {
184    let param = sResPara;
185    let materialType = SceneTest.MaterialType.SHADER;
186    let info = SceneTest.getMaterial();
187    let err: BusinessError = new BusinessError();
188    try {
189        info = sResFactory.createMaterialPro(param, materialType);
190    } catch (e) {
191        err = e as BusinessError;
192    }
193
194    console.log("createMaterial is: " + info.materialType);
195    assertEQ(info.materialType, 122 as byte);
196}
197
198function test_ani_graphics3d_scene_createMaterial_promise() {
199    let param = sResPara;
200    let materialType = SceneTest.MaterialType.SHADER;
201    let info = SceneTest.getMaterial();
202    let err: BusinessError = new BusinessError();
203    try {
204        info = await sResFactory.createMaterial(param, materialType);
205    } catch (e) {
206        err = e as BusinessError;
207    }
208
209    console.log("createMaterial is: " + info.materialType);
210    assertEQ(info.materialType, 122 as byte);
211}
212
213function test_ani_graphics3d_scene_createMaterial_sync() {
214    let param = sResPara;
215    let materialType = SceneTest.MaterialType.SHADER;
216    let promise = new Promise<SceneTest.Material>((resolve, reject) => {
217        sResFactory.createMaterial(param, materialType, (err: BusinessError, data: SceneTest.Material) => {
218            if (err.code !== 0) {
219                reject(err);
220            } else {
221                resolve(data);
222            }
223        });
224    });
225
226    let info = SceneTest.getMaterial();
227    let err: BusinessError = new BusinessError();
228    try {
229        info = await promise;
230    } catch (e) {
231        err = e as BusinessError;
232    }
233
234    console.log("createMaterial is: " + info.materialType);
235    assertEQ(info.materialType, 122 as byte);
236}
237
238function test_ani_graphics3d_scene_createShader() {
239    let param = sResPara;
240    let info = SceneTest.getShader();
241    let err: BusinessError = new BusinessError();
242    try {
243        info = sResFactory.createShaderPro(param);
244    } catch (e) {
245        err = e as BusinessError;
246    }
247
248    console.log("createShader is: " + info.inputs);
249    assertEQ(info.inputs.size, 1);
250}
251
252function test_ani_graphics3d_scene_createShader_promise() {
253    let param = sResPara;
254    let info = SceneTest.getShader();
255    let err: BusinessError = new BusinessError();
256    try {
257        info = await sResFactory.createShader(param);
258    } catch (e) {
259        err = e as BusinessError;
260    }
261
262    console.log("createShader is: " + info.inputs);
263    assertEQ(info.inputs.size, 1);
264}
265
266function test_ani_graphics3d_scene_createShader_sync() {
267    let param = sResPara;
268    let promise = new Promise<SceneTest.Shader>((resolve, reject) => {
269        sResFactory.createShader(param, (err: BusinessError, data: SceneTest.Shader) => {
270            if (err.code !== 0) {
271                reject(err);
272            } else {
273                resolve(data);
274            }
275        });
276    });
277
278    let info = SceneTest.getShader();
279    let err: BusinessError = new BusinessError();
280    try {
281        info = await promise;
282    } catch (e) {
283        err = e as BusinessError;
284    }
285
286    console.log("createShader is: " + info.inputs);
287    assertEQ(info.inputs.size, 1);
288}
289
290function test_ani_graphics3d_scene_createImage() {
291    let param = sResPara;
292    let info = SceneTest.getImage();
293    let err: BusinessError = new BusinessError();
294    try {
295        info = sResFactory.createImagePro(param);
296    } catch (e) {
297        err = e as BusinessError;
298    }
299
300    console.log("createImage is: " + info.width);
301    assertEQ(info.width, 800);
302}
303
304function test_ani_graphics3d_scene_createImage_promise() {
305    let param = sResPara;
306    let info = SceneTest.getImage();
307    let err: BusinessError = new BusinessError();
308    try {
309        info = await sResFactory.createImage(param);
310    } catch (e) {
311        err = e as BusinessError;
312    }
313
314    console.log("createImage is: " + info);
315    assertEQ(info.height, 600);
316}
317
318function test_ani_graphics3d_scene_createImage_sync() {
319    let param = sResPara;
320    let promise = new Promise<SceneTest.Image>((resolve, reject) => {
321        sResFactory.createImage(param, (err: BusinessError, data: SceneTest.Image) => {
322            if (err.code !== 0) {
323                reject(err);
324            } else {
325                resolve(data);
326            }
327        });
328    });
329
330    let info = SceneTest.getImage();
331    let err: BusinessError = new BusinessError();
332    try {
333        info = await promise;
334    } catch (e) {
335        err = e as BusinessError;
336    }
337
338    console.log("createImage is: " + info);
339    assertEQ(info.height, 600);
340}
341
342function test_ani_graphics3d_scene_createEnvironment() {
343    let param = sResPara;
344    let info = SceneTest.getEnvironment();
345    let err: BusinessError = new BusinessError();
346    try {
347        info = sResFactory.createEnvironmentPro(param);
348    } catch (e) {
349        err = e as BusinessError;
350    }
351
352    console.log("createEnvironment is: " + info);
353    assertEQ(info.backgroundType, 0);
354}
355
356function test_ani_graphics3d_scene_createEnvironment_promise() {
357    let param = sResPara;
358    let info = SceneTest.getEnvironment();
359    let err: BusinessError = new BusinessError();
360    try {
361        info = await sResFactory.createEnvironment(param);
362    } catch (e) {
363        err = e as BusinessError;
364    }
365
366    console.log("createEnvironment is: " + info);
367    assertEQ(info.backgroundType, 0);
368}
369
370function test_ani_graphics3d_scene_createEnvironment_sync() {
371    let param = sResPara;
372    let promise = new Promise<SceneTest.Environment>((resolve, reject) => {
373        sResFactory.createEnvironment(param, (err: BusinessError, data: SceneTest.Environment) => {
374            if (err.code !== 0) {
375                reject(err);
376            } else {
377                resolve(data);
378            }
379        });
380    });
381
382    let info = SceneTest.getEnvironment();
383    let err: BusinessError = new BusinessError();
384    try {
385        info = await promise;
386    } catch (e) {
387        err = e as BusinessError;
388    }
389
390    console.log("createEnvironment is: " + info);
391    assertEQ(info.backgroundType, 0);
392}
393
394function main() {
395    console.log("############## start ani_graphics3d #############");
396    const suite = new ArkTestsuite("ani_graphics3d Tests");
397
398    suite.addTest("test_ani_graphics3d_scene_createCamera", test_ani_graphics3d_scene_createCamera)
399    suite.addTest("test_ani_graphics3d_scene_createCamera_promise", test_ani_graphics3d_scene_createCamera_promise)
400    suite.addTest("test_ani_graphics3d_scene_createCamera_sync", test_ani_graphics3d_scene_createCamera_sync)
401    suite.addTest("test_ani_graphics3d_scene_createLight", test_ani_graphics3d_scene_createLight)
402    suite.addTest("test_ani_graphics3d_scene_createLight_promise", test_ani_graphics3d_scene_createLight_promise)
403    suite.addTest("test_ani_graphics3d_scene_createLight_sync", test_ani_graphics3d_scene_createLight_sync)
404    suite.addTest("test_ani_graphics3d_scene_createNode", test_ani_graphics3d_scene_createNode)
405    suite.addTest("test_ani_graphics3d_scene_createNode_promise", test_ani_graphics3d_scene_createNode_promise)
406    suite.addTest("test_ani_graphics3d_scene_createNode_sync", test_ani_graphics3d_scene_createNode_sync)
407    suite.addTest("test_ani_graphics3d_scene_createMaterial", test_ani_graphics3d_scene_createMaterial)
408    suite.addTest("test_ani_graphics3d_scene_createMaterial_promise", test_ani_graphics3d_scene_createMaterial_promise)
409    suite.addTest("test_ani_graphics3d_scene_createMaterial_sync", test_ani_graphics3d_scene_createMaterial_sync)
410    suite.addTest("test_ani_graphics3d_scene_createShader", test_ani_graphics3d_scene_createShader)
411    suite.addTest("test_ani_graphics3d_scene_createShader_promise", test_ani_graphics3d_scene_createShader_promise)
412    suite.addTest("test_ani_graphics3d_scene_createShader_promise", test_ani_graphics3d_scene_createShader_sync)
413    suite.addTest("test_ani_graphics3d_scene_createImage", test_ani_graphics3d_scene_createImage)
414    suite.addTest("test_ani_graphics3d_scene_createImage_promise", test_ani_graphics3d_scene_createImage_promise)
415    suite.addTest("test_ani_graphics3d_scene_createImage_sync", test_ani_graphics3d_scene_createImage_sync)
416    suite.addTest("test_ani_graphics3d_scene_createEnvironment", test_ani_graphics3d_scene_createEnvironment)
417    suite.addTest("test_ani_graphics3d_scene_createEnvironment_promise", test_ani_graphics3d_scene_createEnvironment_promise)
418    suite.addTest("test_ani_graphics3d_scene_createEnvironment_promise", test_ani_graphics3d_scene_createEnvironment_sync)
419
420    exit(suite.run())
421}