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
20using namespace testing;
21using namespace testing::ext;
22
23namespace OHOS {
24namespace Rosen {
25class NativeVsyncTest : public testing::Test {
26public:
27    static void SetUpTestCase();
28    static void TearDownTestCase();
29
30    static inline OH_NativeVSync *native_vsync = nullptr;
31};
32
33void NativeVsyncTest::SetUpTestCase() {}
34
35void NativeVsyncTest::TearDownTestCase() {}
36
37static void OnVSync(long long timestamp, void *data) {}
38
39namespace {
40/*
41 * @tc.name: OH_NativeVSync_Create001
42 * @tc.desc: test for Call OH_NativeVSync_Create and check ret.
43 * @tc.size  : MediumTest
44 * @tc.type  : Function
45 * @tc.level : Level 3
46 */
47HWTEST_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 and check ret.
54 * @tc.size  : MediumTest
55 * @tc.type  : Function
56 * @tc.level : Level 3
57 */
58HWTEST_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 and check ret.
67 * @tc.size  : MediumTest
68 * @tc.type  : Function
69 * @tc.level : Level 3
70 */
71HWTEST_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 and check ret.
78 * @tc.size  : MediumTest
79 * @tc.type  : Function
80 * @tc.level : Level 3
81 */
82HWTEST_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 and check ret.
89 * @tc.size  : MediumTest
90 * @tc.type  : Function
91 * @tc.level : Level 3
92 */
93HWTEST_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 AbNormal OH_NativeVSync_Destroy and check ret.
101 * @tc.size  : MediumTest
102 * @tc.type  : Function
103 * @tc.level : Level 3
104 */
105HWTEST_F(NativeVsyncTest, OH_NativeVSync_Destroy001, Function | MediumTest | Level3) {
106    OH_NativeVSync_Destroy(nullptr);
107}
108
109/*
110 * @tc.name: OH_NativeVSync_Destroy002
111 * @tc.desc: test for Normal OH_NativeVSync_Destroy and check ret.
112 * @tc.size  : MediumTest
113 * @tc.type  : Function
114 * @tc.level : Level 3
115 */
116HWTEST_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 Normal OH_NativeVSync_RequestFrameWithMultiCallback and check ret.
122 * @tc.size  : MediumTest
123 * @tc.type  : Function
124 * @tc.level : Level 3
125 */
126HWTEST_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 AbNormal OH_NativeVSync_RequestFrameWithMultiCallback and check ret.
163 * @tc.size  : MediumTest
164 * @tc.type  : Function
165 * @tc.level : Level 3
166 */
167HWTEST_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