1 /*
2 * Copyright 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #undef LOG_TAG
18 #define LOG_TAG "FpsReporterTest"
19
20 #include <android/gui/BnFpsListener.h>
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23 #include <gui/LayerMetadata.h>
24
25 #include "BufferQueueLayer.h"
26 #include "BufferStateLayer.h"
27 #include "EffectLayer.h"
28 #include "FpsReporter.h"
29 #include "Layer.h"
30 #include "TestableSurfaceFlinger.h"
31 #include "fake/FakeClock.h"
32 #include "mock/DisplayHardware/MockComposer.h"
33 #include "mock/MockEventThread.h"
34 #include "mock/MockFrameTimeline.h"
35 #include "mock/MockVsyncController.h"
36
37 namespace android {
38
39 using testing::_;
40 using testing::DoAll;
41 using testing::Mock;
42 using testing::Return;
43 using testing::SetArgPointee;
44 using testing::UnorderedElementsAre;
45
46 using android::Hwc2::IComposer;
47 using android::Hwc2::IComposerClient;
48
49 using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
50
51 struct TestableFpsListener : public gui::BnFpsListener {
TestableFpsListenerandroid::TestableFpsListener52 TestableFpsListener() {}
53
54 float lastReportedFps = 0;
55
onFpsReportedandroid::TestableFpsListener56 binder::Status onFpsReported(float fps) override {
57 lastReportedFps = fps;
58 return binder::Status::ok();
59 }
60 };
61
62 /**
63 * This class covers all the test that are related to refresh rate selection.
64 */
65 class FpsReporterTest : public testing::Test {
66 public:
67 FpsReporterTest();
68 ~FpsReporterTest() override;
69
70 protected:
71 static constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
72 static constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
73 static constexpr uint32_t WIDTH = 100;
74 static constexpr uint32_t HEIGHT = 100;
75 static constexpr uint32_t LAYER_FLAGS = 0;
76 static constexpr int32_t PRIORITY_UNSET = -1;
77
78 void setupScheduler();
79 sp<BufferStateLayer> createBufferStateLayer(LayerMetadata metadata);
80
81 TestableSurfaceFlinger mFlinger;
82 mock::FrameTimeline mFrameTimeline =
83 mock::FrameTimeline(std::make_shared<impl::TimeStats>(), 0);
84
85 sp<Client> mClient;
86 sp<Layer> mParent;
87 sp<Layer> mTarget;
88 sp<Layer> mChild;
89 sp<Layer> mGrandChild;
90 sp<Layer> mUnrelated;
91
92 sp<TestableFpsListener> mFpsListener;
93 fake::FakeClock* mClock = new fake::FakeClock();
94 sp<FpsReporter> mFpsReporter =
95 new FpsReporter(mFrameTimeline, *(mFlinger.flinger()), std::unique_ptr<Clock>(mClock));
96 };
97
FpsReporterTest()98 FpsReporterTest::FpsReporterTest() {
99 const ::testing::TestInfo* const test_info =
100 ::testing::UnitTest::GetInstance()->current_test_info();
101 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
102
103 setupScheduler();
104 mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());
105
106 mFpsListener = new TestableFpsListener();
107 }
108
~FpsReporterTest()109 FpsReporterTest::~FpsReporterTest() {
110 const ::testing::TestInfo* const test_info =
111 ::testing::UnitTest::GetInstance()->current_test_info();
112 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
113 }
114
createBufferStateLayer(LayerMetadata metadata={})115 sp<BufferStateLayer> FpsReporterTest::createBufferStateLayer(LayerMetadata metadata = {}) {
116 sp<Client> client;
117 LayerCreationArgs args(mFlinger.flinger(), client, "buffer-state-layer", WIDTH, HEIGHT,
118 LAYER_FLAGS, metadata);
119 return new BufferStateLayer(args);
120 }
121
setupScheduler()122 void FpsReporterTest::setupScheduler() {
123 auto eventThread = std::make_unique<mock::EventThread>();
124 auto sfEventThread = std::make_unique<mock::EventThread>();
125
126 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
127 EXPECT_CALL(*eventThread, createEventConnection(_, _))
128 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
129 ResyncCallback())));
130
131 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
132 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
133 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
134 ResyncCallback())));
135
136 auto vsyncController = std::make_unique<mock::VsyncController>();
137 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
138
139 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
140 EXPECT_CALL(*vsyncTracker, currentPeriod())
141 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
142 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
143 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
144 std::move(eventThread), std::move(sfEventThread));
145 }
146
147 namespace {
148
TEST_F(FpsReporterTest,callsListeners)149 TEST_F(FpsReporterTest, callsListeners) {
150 mParent = createBufferStateLayer();
151 constexpr int32_t kTaskId = 12;
152 LayerMetadata targetMetadata;
153 targetMetadata.setInt32(METADATA_TASK_ID, kTaskId);
154 mTarget = createBufferStateLayer(targetMetadata);
155 mChild = createBufferStateLayer();
156 mGrandChild = createBufferStateLayer();
157 mUnrelated = createBufferStateLayer();
158 mParent->addChild(mTarget);
159 mTarget->addChild(mChild);
160 mChild->addChild(mGrandChild);
161 mParent->commitChildList();
162 mFlinger.mutableCurrentState().layersSortedByZ.add(mParent);
163 mFlinger.mutableCurrentState().layersSortedByZ.add(mTarget);
164 mFlinger.mutableCurrentState().layersSortedByZ.add(mChild);
165 mFlinger.mutableCurrentState().layersSortedByZ.add(mGrandChild);
166
167 float expectedFps = 44.0;
168
169 EXPECT_CALL(mFrameTimeline,
170 computeFps(UnorderedElementsAre(mTarget->getSequence(), mChild->getSequence(),
171 mGrandChild->getSequence())))
172 .WillOnce(Return(expectedFps));
173
174 mFpsReporter->addListener(mFpsListener, kTaskId);
175 mClock->advanceTime(600ms);
176 mFpsReporter->dispatchLayerFps();
177 EXPECT_EQ(expectedFps, mFpsListener->lastReportedFps);
178 mFpsReporter->removeListener(mFpsListener);
179 Mock::VerifyAndClearExpectations(&mFrameTimeline);
180
181 EXPECT_CALL(mFrameTimeline, computeFps(_)).Times(0);
182 mFpsReporter->dispatchLayerFps();
183 }
184
TEST_F(FpsReporterTest,rateLimits)185 TEST_F(FpsReporterTest, rateLimits) {
186 const constexpr int32_t kTaskId = 12;
187 LayerMetadata targetMetadata;
188 targetMetadata.setInt32(METADATA_TASK_ID, kTaskId);
189 mTarget = createBufferStateLayer(targetMetadata);
190 mFlinger.mutableCurrentState().layersSortedByZ.add(mTarget);
191
192 float firstFps = 44.0;
193 float secondFps = 53.0;
194
195 EXPECT_CALL(mFrameTimeline, computeFps(UnorderedElementsAre(mTarget->getSequence())))
196 .WillOnce(Return(firstFps))
197 .WillOnce(Return(secondFps));
198
199 mFpsReporter->addListener(mFpsListener, kTaskId);
200 mClock->advanceTime(600ms);
201 mFpsReporter->dispatchLayerFps();
202 EXPECT_EQ(firstFps, mFpsListener->lastReportedFps);
203 mClock->advanceTime(200ms);
204 mFpsReporter->dispatchLayerFps();
205 EXPECT_EQ(firstFps, mFpsListener->lastReportedFps);
206 mClock->advanceTime(200ms);
207 mFpsReporter->dispatchLayerFps();
208 EXPECT_EQ(firstFps, mFpsListener->lastReportedFps);
209 mClock->advanceTime(200ms);
210 mFpsReporter->dispatchLayerFps();
211 EXPECT_EQ(secondFps, mFpsListener->lastReportedFps);
212 }
213
214 } // namespace
215 } // namespace android
216