Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 88d11b00 authored by Leon Scroggins's avatar Leon Scroggins Committed by Automerger Merge Worker
Browse files

Merge "Add tests for VsyncSchedule" into udc-dev am: 76a3e59e 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/21542449



Change-Id: I64d95ee8bcf64f6451454cbb7e1f9ec0061fd9d9
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 380c52a8 76a3e59e

services/surfaceflinger/Scheduler/VsyncSchedule.h

+3 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <string>



#include <ThreadContext.h>

#include <android-base/thread_annotations.h>

#include <ftl/enum.h>

#include <ftl/optional.h>

#include <scheduler/Features.h>
@@ -27,6 +28,7 @@ 


namespace android {

class EventThreadTest;

class VsyncScheduleTest;

}



namespace android::fuzz {
@@ -96,6 +98,7 @@ public: 
private:

    friend class TestableScheduler;

    friend class android::EventThreadTest;

    friend class android::VsyncScheduleTest;

    friend class android::fuzz::SchedulerFuzzer;



    using TrackerPtr = std::unique_ptr<VsyncTracker>;

services/surfaceflinger/tests/unittests/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -134,6 +134,7 @@ cc_test { 
        "VSyncPredictorTest.cpp",

        "VSyncReactorTest.cpp",

        "VsyncConfigurationTest.cpp",

        "VsyncScheduleTest.cpp",

    ],

}

services/surfaceflinger/tests/unittests/VsyncScheduleTest.cpp

0 → 100644
+215 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#undef LOG_TAG

#define LOG_TAG "LibSurfaceFlingerUnittests"



#include <ftl/fake_guard.h>

#include <gmock/gmock.h>

#include <gtest/gtest.h>

#include <log/log.h>



#include <scheduler/Fps.h>

#include "Scheduler/VsyncSchedule.h"

#include "ThreadContext.h"

#include "mock/MockSchedulerCallback.h"

#include "mock/MockVSyncDispatch.h"

#include "mock/MockVSyncTracker.h"

#include "mock/MockVsyncController.h"



using testing::_;



namespace android {



class VsyncScheduleTest : public testing::Test {

protected:

    VsyncScheduleTest();

    ~VsyncScheduleTest() override;



    scheduler::mock::SchedulerCallback mCallback;

    const std::unique_ptr<scheduler::VsyncSchedule> mVsyncSchedule =

            std::unique_ptr<scheduler::VsyncSchedule>(

                    new scheduler::VsyncSchedule(std::make_unique<mock::VSyncTracker>(),

                                                 std::make_unique<mock::VSyncDispatch>(),

                                                 std::make_unique<mock::VsyncController>()));



    mock::VsyncController& getController() {

        return *static_cast<mock::VsyncController*>(&mVsyncSchedule->getController());

    }

};



VsyncScheduleTest::VsyncScheduleTest() {

    const ::testing::TestInfo* const test_info =

            ::testing::UnitTest::GetInstance()->current_test_info();

    ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());

}



VsyncScheduleTest::~VsyncScheduleTest() {

    const ::testing::TestInfo* const test_info =

            ::testing::UnitTest::GetInstance()->current_test_info();

    ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());

}



namespace {



using namespace testing;



TEST_F(VsyncScheduleTest, InitiallyDisallowed) {

    ASSERT_FALSE(mVsyncSchedule->isHardwareVsyncAllowed(false /* makeAllowed */));

}



TEST_F(VsyncScheduleTest, EnableDoesNothingWhenDisallowed) {

    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);



    mVsyncSchedule->enableHardwareVsync(mCallback);

}



TEST_F(VsyncScheduleTest, DisableDoesNothingWhenDisallowed) {

    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);



    mVsyncSchedule->disableHardwareVsync(mCallback, false /* disallow */);

}



TEST_F(VsyncScheduleTest, MakeAllowed) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

}



TEST_F(VsyncScheduleTest, DisableDoesNothingWhenDisabled) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);



    mVsyncSchedule->disableHardwareVsync(mCallback, false /* disallow */);

}



TEST_F(VsyncScheduleTest, EnableWorksWhenDisabled) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    EXPECT_CALL(mCallback, setVsyncEnabled(true));



    mVsyncSchedule->enableHardwareVsync(mCallback);

}



TEST_F(VsyncScheduleTest, EnableWorksOnce) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    EXPECT_CALL(mCallback, setVsyncEnabled(true));



    mVsyncSchedule->enableHardwareVsync(mCallback);



    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);

    mVsyncSchedule->enableHardwareVsync(mCallback);

}



TEST_F(VsyncScheduleTest, AllowedIsSticky) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(false /* makeAllowed */));

}



TEST_F(VsyncScheduleTest, EnableDisable) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    EXPECT_CALL(mCallback, setVsyncEnabled(true));



    mVsyncSchedule->enableHardwareVsync(mCallback);



    EXPECT_CALL(mCallback, setVsyncEnabled(false));

    mVsyncSchedule->disableHardwareVsync(mCallback, false /* disallow */);

}



TEST_F(VsyncScheduleTest, StartPeriodTransition) {

    // Note: startPeriodTransition is only called when hardware vsyncs are

    // allowed.

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));



    const Period period = (60_Hz).getPeriod();



    EXPECT_CALL(mCallback, setVsyncEnabled(true));

    EXPECT_CALL(getController(), startPeriodTransition(period.ns()));



    mVsyncSchedule->startPeriodTransition(mCallback, period);

}



TEST_F(VsyncScheduleTest, StartPeriodTransitionAlreadyEnabled) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    mVsyncSchedule->enableHardwareVsync(mCallback);



    const Period period = (60_Hz).getPeriod();



    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);

    EXPECT_CALL(getController(), startPeriodTransition(period.ns()));



    mVsyncSchedule->startPeriodTransition(mCallback, period);

}



TEST_F(VsyncScheduleTest, AddResyncSampleDisallowed) {

    const Period period = (60_Hz).getPeriod();

    const auto timestamp = TimePoint::now();



    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);

    EXPECT_CALL(getController(), addHwVsyncTimestamp(_, _, _)).Times(0);



    mVsyncSchedule->addResyncSample(mCallback, timestamp, period);

}



TEST_F(VsyncScheduleTest, AddResyncSampleDisabled) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    const Period period = (60_Hz).getPeriod();

    const auto timestamp = TimePoint::now();



    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);

    EXPECT_CALL(getController(), addHwVsyncTimestamp(_, _, _)).Times(0);



    mVsyncSchedule->addResyncSample(mCallback, timestamp, period);

}



TEST_F(VsyncScheduleTest, AddResyncSampleReturnsTrue) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    mVsyncSchedule->enableHardwareVsync(mCallback);



    const Period period = (60_Hz).getPeriod();

    const auto timestamp = TimePoint::now();



    EXPECT_CALL(mCallback, setVsyncEnabled(_)).Times(0);

    EXPECT_CALL(getController(),

                addHwVsyncTimestamp(timestamp.ns(), std::optional<nsecs_t>(period.ns()), _))

            .WillOnce(Return(true));



    mVsyncSchedule->addResyncSample(mCallback, timestamp, period);

}



TEST_F(VsyncScheduleTest, AddResyncSampleReturnsFalse) {

    ASSERT_TRUE(mVsyncSchedule->isHardwareVsyncAllowed(true /* makeAllowed */));

    mVsyncSchedule->enableHardwareVsync(mCallback);



    const Period period = (60_Hz).getPeriod();

    const auto timestamp = TimePoint::now();



    EXPECT_CALL(mCallback, setVsyncEnabled(false));

    EXPECT_CALL(getController(),

                addHwVsyncTimestamp(timestamp.ns(), std::optional<nsecs_t>(period.ns()), _))

            .WillOnce(Return(false));



    mVsyncSchedule->addResyncSample(mCallback, timestamp, period);

}



TEST_F(VsyncScheduleTest, PendingState) FTL_FAKE_GUARD(kMainThreadContext) {

    ASSERT_FALSE(mVsyncSchedule->getPendingHardwareVsyncState());

    mVsyncSchedule->setPendingHardwareVsyncState(true);

    ASSERT_TRUE(mVsyncSchedule->getPendingHardwareVsyncState());



    mVsyncSchedule->setPendingHardwareVsyncState(false);

    ASSERT_FALSE(mVsyncSchedule->getPendingHardwareVsyncState());

}



} // namespace

} // namespace android

services/surfaceflinger/tests/unittests/mock/MockSchedulerCallback.h

+1 −1
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 


#include <gmock/gmock.h>



#include "Scheduler/Scheduler.h"

#include "Scheduler/ISchedulerCallback.h"



namespace android::scheduler::mock {