1 /*
2 * Copyright (c) 2022 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 #include <gtest/gtest.h>
16 #include "native_vsync.h"
17 #include <thread>
18 #include "graphic_error_code.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 class NativeVsyncTest : public testing::Test {
26 public:
27 static void SetUpTestCase();
28 static void TearDownTestCase();
29
30 static inline OH_NativeVSync *native_vsync = nullptr;
31 };
32
SetUpTestCase()33 void NativeVsyncTest::SetUpTestCase() {}
34
TearDownTestCase()35 void NativeVsyncTest::TearDownTestCase() {}
36
OnVSync(long long timestamp,void * data)37 static void OnVSync(long long timestamp, void *data) {}
38
39 namespace {
40 /*
41 * @tc.name: OH_NativeVSync_Create001
42 * @tc.desc: test for call OH_NativeVSync_Create by abnormal input and check ret
43 * @tc.size : MediumTest
44 * @tc.type : Function
45 * @tc.Level: Level 2
46 */
47 HWTEST_F(NativeVsyncTest, OH_NativeVSync_Create001, Function | MediumTest | Level2) {
48 ASSERT_EQ(OH_NativeVSync_Create(nullptr, 0), nullptr);
49 }
50
51 /*
52 * @tc.name: OH_NativeVSync_Create002
53 * @tc.desc: test for call OH_NativeVSync_Create by abnormal input and check ret
54 * @tc.size : MediumTest
55 * @tc.type : Function
56 * @tc.Level: Level 2
57 */
58 HWTEST_F(NativeVsyncTest, OH_NativeVSync_Create002, Function | MediumTest | Level2) {
59 char name[] = "test";
60 native_vsync = OH_NativeVSync_Create(name, sizeof(name));
61 ASSERT_NE(native_vsync, nullptr);
62 }
63
64 /*
65 * @tc.name: OH_NativeVSync_RequestFrame001
66 * @tc.desc: test for call OH_NativeVSync_RequestFrame by abnormal input and check ret
67 * @tc.size : MediumTest
68 * @tc.type : Function
69 * @tc.Level: Level 2
70 */
71 HWTEST_F(NativeVsyncTest, OH_NativeVSync_RequestFrame001, Function | MediumTest | Level2) {
72 ASSERT_NE(OH_NativeVSync_RequestFrame(nullptr, nullptr, nullptr), 0);
73 }
74
75 /*
76 * @tc.name: OH_NativeVSync_RequestFrame002
77 * @tc.desc: test for call OH_NativeVSync_RequestFrame by abnormal input and check ret
78 * @tc.size : MediumTest
79 * @tc.type : Function
80 * @tc.Level: Level 2
81 */
82 HWTEST_F(NativeVsyncTest, OH_NativeVSync_RequestFrame002, Function | MediumTest | Level2) {
83 ASSERT_NE(OH_NativeVSync_RequestFrame(native_vsync, nullptr, nullptr), 0);
84 }
85
86 /*
87 * @tc.name: OH_NativeVSync_RequestFrame003
88 * @tc.desc: test for call OH_NativeVSync_RequestFrame by abnormal input and check ret
89 * @tc.size : MediumTest
90 * @tc.type : Function
91 * @tc.Level: Level 2
92 */
93 HWTEST_F(NativeVsyncTest, OH_NativeVSync_RequestFrame003, Function | MediumTest | Level2) {
94 OH_NativeVSync_FrameCallback callback = OnVSync;
95 ASSERT_EQ(OH_NativeVSync_RequestFrame(native_vsync, callback, nullptr), 0);
96 }
97
98 /*
99 * @tc.name: OH_NativeVSync_Destroy001
100 * @tc.desc: test for call OH_NativeVSync_Destroy by abnormal input and check ret
101 * @tc.size : MediumTest
102 * @tc.type : Function
103 * @tc.Level: Level 2
104 */
105 HWTEST_F(NativeVsyncTest, OH_NativeVSync_Destroy001, Function | MediumTest | Level2) {
106 OH_NativeVSync_Destroy(nullptr);
107 }
108
109 /*
110 * @tc.name: OH_NativeVSync_Destroy002
111 * @tc.desc: test for call OH_NativeVSync_Destroy by abnormal input and check ret
112 * @tc.size : MediumTest
113 * @tc.type : Function
114 * @tc.Level: Level 2
115 */
116 HWTEST_F(NativeVsyncTest, OH_NativeVSync_Destroy002, Function | MediumTest | Level2) {
117 OH_NativeVSync_Destroy(native_vsync);
118 }
119 /*
120 * @tc.name: OH_NativeVSync_RequestFrameWithMultiCallbackNormal
121 * @tc.desc: test for call OH_NativeVSync_RequestFrameWithMultiCallback by abnormal input and check ret
122 * @tc.size : MediumTest
123 * @tc.type : Function
124 * @tc.Level: Level 2
125 */
126 HWTEST_F(NativeVsyncTest, OH_NativeVSync_RequestFrameWithMultiCallbackNormal, Function | MediumTest | Level2) {
127 char name[] = "test";
128 native_vsync = OH_NativeVSync_Create(name, sizeof(name));
129 ASSERT_NE(native_vsync, nullptr);
130 OH_NativeVSync_FrameCallback callback = OnVSync;
131 auto *data = new std::string("hello");
132 OH_NativeVSync_RequestFrame(native_vsync, callback, data);
133 int ret = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, data);
134 OH_NativeVSync_RequestFrame(native_vsync, callback, nullptr);
135 int ret1 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, data);
136 ASSERT_EQ(ret, NATIVE_ERROR_OK);
137 ASSERT_EQ(ret1, NATIVE_ERROR_OK);
138 for (int i = 0; i < 5; i++) {
139 int ret2 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, data);
140 std::this_thread::sleep_for(std::chrono::milliseconds(1));
141 ASSERT_EQ(ret2, NATIVE_ERROR_OK);
142 }
143 for (int i = 0; i < 5; i++) {
144 int ret3 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, data + i);
145 std::this_thread::sleep_for(std::chrono::milliseconds(1));
146 ASSERT_EQ(ret3, NATIVE_ERROR_OK);
147 }
148 for (int i = 0; i < 100; i++) {
149 int ret100 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, data);
150 std::this_thread::sleep_for(std::chrono::milliseconds(1));
151 ASSERT_EQ(ret100, NATIVE_ERROR_OK);
152 }
153 for (int i = 0; i < 1000; i++) {
154 int ret1000 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, data);
155 std::this_thread::sleep_for(std::chrono::milliseconds(1));
156 ASSERT_EQ(ret1000, NATIVE_ERROR_OK);
157 }
158 OH_NativeVSync_Destroy(native_vsync);
159 }
160 /*
161 * @tc.name: OH_NativeVSync_RequestFrameWithMultiCallbackAbnormal
162 * @tc.desc: test for call OH_NativeVSync_RequestFrameWithMultiCallback by abnormal input and check ret
163 * @tc.size : MediumTest
164 * @tc.type : Function
165 * @tc.Level: Level 3
166 */
167 HWTEST_F(NativeVsyncTest, OH_NativeVSync_RequestFrameWithMultiCallbackAbnormal, Function | MediumTest | Level3) {
168 char name[] = "test";
169 native_vsync = OH_NativeVSync_Create(name, sizeof(name));
170 ASSERT_NE(native_vsync, nullptr);
171 OH_NativeVSync_FrameCallback callback = OnVSync;
172 auto *data = new std::string("hello");
173 int ret3 = OH_NativeVSync_RequestFrameWithMultiCallback(nullptr, callback, data);
174 ASSERT_EQ(ret3, NATIVE_ERROR_INVALID_ARGUMENTS);
175 int ret4 = OH_NativeVSync_RequestFrameWithMultiCallback(0, callback, data);
176 ASSERT_EQ(ret4, NATIVE_ERROR_INVALID_ARGUMENTS);
177 int ret5 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, nullptr, data);
178 ASSERT_EQ(ret5, NATIVE_ERROR_INVALID_ARGUMENTS);
179 int ret6 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, 0, data);
180 ASSERT_EQ(ret6, NATIVE_ERROR_INVALID_ARGUMENTS);
181 int ret7 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, nullptr);
182 ASSERT_EQ(ret7, NATIVE_ERROR_OK);
183 int ret8 = OH_NativeVSync_RequestFrameWithMultiCallback(native_vsync, callback, 0);
184 ASSERT_EQ(ret8, NATIVE_ERROR_OK);
185 OH_NativeVSync_Destroy(native_vsync);
186 }
187 } // namespace
188 } // namespace Rosen
189 } // namespace OHOS