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, Hardware
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
16 #include <gtest/gtest.h>
17 #include <test_header.h>
18
19 #include "frame_collector.h"
20 #include "frame_painter.h"
21 #ifndef USE_ROSEN_DRAWING
22 #include "include/core/SkBitmap.h"
23 #include "include/core/SkCanvas.h"
24 #else
25 #include "draw/canvas.h"
26 #include "image/bitmap.h"
27 #endif
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34 class FramePainterTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 };
41
SetUpTestCase()42 void FramePainterTest::SetUpTestCase() {}
TearDownTestCase()43 void FramePainterTest::TearDownTestCase() {}
SetUp()44 void FramePainterTest::SetUp() {}
TearDown()45 void FramePainterTest::TearDown() {}
46
47 /**
48 * @tc.name: Create001
49 * @tc.desc: test
50 * @tc.type:FUNC
51 * @tc.require:
52 */
53 HWTEST_F(FramePainterTest, Create001, TestSize.Level1)
54 {
55 FramePainter* painter_ptr = new FramePainter(FrameCollector::GetInstance());
56 ASSERT_TRUE(painter_ptr != nullptr);
57 }
58
59 /**
60 * @tc.name: FramePainterTest
61 * @tc.desc: Test RsNodeCostManagerTest.SwitchFunction2
62 * @tc.type: FUNC
63 * @tc.require: I6R1BQ
64 */
65 HWTEST_F(FramePainterTest, DrawTest1, TestSize.Level1)
66 {
67 FrameCollector& controller = FrameCollector::GetInstance();
68 controller.SetEnabled(true);
69 auto framePainter = std::make_shared<FramePainter>(controller);
70 #ifndef USE_ROSEN_DRAWING
71 SkBitmap bitmap;
72 SkCanvas canvas(bitmap);
73 #else
74 Drawing::Bitmap bitmap;
75 Drawing::Canvas canvas;
76 canvas.Bind(bitmap);
77 #endif
78 framePainter->Draw(canvas);
79 ASSERT_TRUE(controller.IsEnabled());
80 }
81
82 /**
83 * @tc.name: FramePainterTest
84 * @tc.desc: Test RsNodeCostManagerTest.SwitchFunction2
85 * @tc.type: FUNC
86 * @tc.require: I6R1BQ
87 */
88 HWTEST_F(FramePainterTest, DrawTest2, TestSize.Level1)
89 {
90 FrameCollector& controller = FrameCollector::GetInstance();
91 controller.SetEnabled(false);
92 auto framePainter = std::make_shared<FramePainter>(controller);
93 #ifndef USE_ROSEN_DRAWING
94 SkBitmap bitmap;
95 SkCanvas canvas(bitmap);
96 #else
97 Drawing::Bitmap bitmap;
98 Drawing::Canvas canvas;
99 canvas.Bind(bitmap);
100 #endif
101 framePainter->Draw(canvas);
102 ASSERT_FALSE(controller.IsEnabled());
103 }
104
105 /**
106 * @tc.name: FramePainterTest
107 * @tc.desc: Test RsNodeCostManagerTest.DrawFPSLine
108 * @tc.type: FUNC
109 * @tc.require: I6R1BQ
110 */
111 HWTEST_F(FramePainterTest, DrawFPSLine1, TestSize.Level1)
112 {
113 FrameCollector& controller = FrameCollector::GetInstance();
114 controller.SetEnabled(false);
115 auto framePainter = std::make_shared<FramePainter>(controller);
116 #ifndef USE_ROSEN_DRAWING
117 SkBitmap bitmap;
118 SkCanvas canvas(bitmap);
119 #else
120 Drawing::Bitmap bitmap;
121 Drawing::Canvas canvas;
122 canvas.Bind(bitmap);
123 #endif
124 framePainter->DrawFPSLine(canvas, 0, 2.0f, 0xbf00ff00);
125 ASSERT_FALSE(controller.IsEnabled());
126 }
127
128 /**
129 * @tc.name: FramePainterTest
130 * @tc.desc: Test RsNodeCostManagerTest.DrawFPSLine
131 * @tc.type: FUNC
132 * @tc.require: I6R1BQ
133 */
134 HWTEST_F(FramePainterTest, DrawFPSLine2, TestSize.Level1)
135 {
136 FrameCollector& controller = FrameCollector::GetInstance();
137 controller.SetEnabled(false);
138 auto framePainter = std::make_shared<FramePainter>(controller);
139 #ifndef USE_ROSEN_DRAWING
140 SkBitmap bitmap;
141 SkCanvas canvas(bitmap);
142 #else
143 Drawing::Bitmap bitmap;
144 Drawing::Canvas canvas;
145 canvas.Bind(bitmap);
146 #endif
147 framePainter->DrawFPSLine(canvas, 1, 2.0f, 0xbf00ff00);
148 ASSERT_FALSE(controller.IsEnabled());
149 }
150
151 /**
152 * @tc.name: FramePainterTest
153 * @tc.desc: Test RsNodeCostManagerTest.GenerateTimeBars
154 * @tc.type: FUNC
155 * @tc.require: I6R1BQ
156 */
157 HWTEST_F(FramePainterTest, GenerateTimeBars, TestSize.Level1)
158 {
159 FrameCollector& controller = FrameCollector::GetInstance();
160 controller.SetEnabled(false);
161 auto framePainter = std::make_shared<FramePainter>(controller);
162 framePainter->GenerateTimeBars(1600, 800, 1);
163 ASSERT_FALSE(controller.IsEnabled());
164 }
165
166 /**
167 * @tc.name: FramePainterTest
168 * @tc.desc: Test RsNodeCostManagerTest.GenerateTimeBars
169 * @tc.type: FUNC
170 * @tc.require: I6R1BQ
171 */
172 HWTEST_F(FramePainterTest, SumTimesInMs, TestSize.Level1)
173 {
174 FrameCollector& controller = FrameCollector::GetInstance();
175 controller.SetEnabled(false);
176 auto framePainter = std::make_shared<FramePainter>(controller);
177 FrameInfo info;
178 double result = framePainter->SumTimesInMs(info);
179 ASSERT_FALSE(controller.IsEnabled());
180 ASSERT_EQ(result, 0);
181 }
182
183 } // namespace Rosen
184 } // namespace OHOS
185