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

Commit d4765423 authored by Yiwei Zhang's avatar Yiwei Zhang
Browse files

Game Driver Metrics: add tests for GpuStatsPuller 

Bug: 123529932
Test: atest GpuStatsPuller_test
Change-Id: I325f90d203539b51ee0a9deb2b048b8671e5e89a
parent 4fb9289a

cmds/statsd/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -219,6 +219,7 @@ cc_test { 
        "tests/anomaly/AnomalyTracker_test.cpp",

        "tests/ConfigManager_test.cpp",

        "tests/external/puller_util_test.cpp",

        "tests/external/GpuStatsPuller_test.cpp",

        "tests/external/IncidentReportArgs_test.cpp",

        "tests/external/StatsPuller_test.cpp",

        "tests/indexed_priority_queue_test.cpp",

cmds/statsd/tests/external/GpuStatsPuller_test.cpp

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

 * Copyright 2019 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 "GpuStatsPuller_test"



#include <gmock/gmock.h>

#include <gtest/gtest.h>



#include <graphicsenv/GpuStatsInfo.h>

#include <log/log.h>



#include "src/external/GpuStatsPuller.h"



#ifdef __ANDROID__



namespace android {

namespace os {

namespace statsd {



// clang-format off

static const std::string DRIVER_PACKAGE_NAME    = "TEST_DRIVER";

static const std::string DRIVER_VERSION_NAME    = "TEST_DRIVER_VERSION";

static const std::string APP_PACKAGE_NAME       = "TEST_APP";

static const int64_t TIMESTAMP_WALLCLOCK        = 111;

static const int64_t TIMESTAMP_ELAPSED          = 222;

static const int64_t DRIVER_VERSION_CODE        = 333;

static const int64_t DRIVER_BUILD_TIME          = 444;

static const int64_t GL_LOADING_COUNT           = 3;

static const int64_t GL_LOADING_FAILURE_COUNT   = 1;

static const int64_t VK_LOADING_COUNT           = 4;

static const int64_t VK_LOADING_FAILURE_COUNT   = 0;

static const int64_t GL_DRIVER_LOADING_TIME_0   = 555;

static const int64_t GL_DRIVER_LOADING_TIME_1   = 666;

static const int64_t VK_DRIVER_LOADING_TIME_0   = 777;

static const int64_t VK_DRIVER_LOADING_TIME_1   = 888;

static const int64_t VK_DRIVER_LOADING_TIME_2   = 999;

static const size_t NUMBER_OF_VALUES_GLOBAL     = 8;

static const size_t NUMBER_OF_VALUES_APP        = 4;

// clang-format on



class MockGpuStatsPuller : public GpuStatsPuller {

public:

    MockGpuStatsPuller(const int tagId, vector<std::shared_ptr<LogEvent>>* data)

        : GpuStatsPuller(tagId), mData(data){};



private:

    bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override {

        *data = *mData;

        return true;

    }



    vector<std::shared_ptr<LogEvent>>* mData;

};



class GpuStatsPuller_test : public ::testing::Test {

public:

    GpuStatsPuller_test() {

        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());

    }



    ~GpuStatsPuller_test() {

        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());

    }

};



TEST_F(GpuStatsPuller_test, PullGpuStatsGlobalInfo) {

    vector<std::shared_ptr<LogEvent>> inData, outData;

    std::shared_ptr<LogEvent> event = make_shared<LogEvent>(android::util::GPU_STATS_GLOBAL_INFO,

                                                            TIMESTAMP_WALLCLOCK, TIMESTAMP_ELAPSED);

    EXPECT_TRUE(event->write(DRIVER_PACKAGE_NAME));

    EXPECT_TRUE(event->write(DRIVER_VERSION_NAME));

    EXPECT_TRUE(event->write(DRIVER_VERSION_CODE));

    EXPECT_TRUE(event->write(DRIVER_BUILD_TIME));

    EXPECT_TRUE(event->write(GL_LOADING_COUNT));

    EXPECT_TRUE(event->write(GL_LOADING_FAILURE_COUNT));

    EXPECT_TRUE(event->write(VK_LOADING_COUNT));

    EXPECT_TRUE(event->write(VK_LOADING_FAILURE_COUNT));

    event->init();

    inData.emplace_back(event);

    MockGpuStatsPuller mockPuller(android::util::GPU_STATS_GLOBAL_INFO, &inData);

    mockPuller.ForceClearCache();

    mockPuller.Pull(&outData);



    ASSERT_EQ(1, outData.size());

    EXPECT_EQ(android::util::GPU_STATS_GLOBAL_INFO, outData[0]->GetTagId());

    ASSERT_EQ(NUMBER_OF_VALUES_GLOBAL, outData[0]->size());

    EXPECT_EQ(DRIVER_PACKAGE_NAME, outData[0]->getValues()[0].mValue.str_value);

    EXPECT_EQ(DRIVER_VERSION_NAME, outData[0]->getValues()[1].mValue.str_value);

    EXPECT_EQ(DRIVER_VERSION_CODE, outData[0]->getValues()[2].mValue.long_value);

    EXPECT_EQ(DRIVER_BUILD_TIME, outData[0]->getValues()[3].mValue.long_value);

    EXPECT_EQ(GL_LOADING_COUNT, outData[0]->getValues()[4].mValue.long_value);

    EXPECT_EQ(GL_LOADING_FAILURE_COUNT, outData[0]->getValues()[5].mValue.long_value);

    EXPECT_EQ(VK_LOADING_COUNT, outData[0]->getValues()[6].mValue.long_value);

    EXPECT_EQ(VK_LOADING_FAILURE_COUNT, outData[0]->getValues()[7].mValue.long_value);

}



TEST_F(GpuStatsPuller_test, PullGpuStatsAppInfo) {

    vector<std::shared_ptr<LogEvent>> inData, outData;

    std::shared_ptr<LogEvent> event = make_shared<LogEvent>(android::util::GPU_STATS_APP_INFO,

                                                            TIMESTAMP_WALLCLOCK, TIMESTAMP_ELAPSED);

    EXPECT_TRUE(event->write(APP_PACKAGE_NAME));

    EXPECT_TRUE(event->write(DRIVER_VERSION_CODE));

    std::vector<int64_t> glDriverLoadingTime;

    glDriverLoadingTime.emplace_back(GL_DRIVER_LOADING_TIME_0);

    glDriverLoadingTime.emplace_back(GL_DRIVER_LOADING_TIME_1);

    std::vector<int64_t> vkDriverLoadingTime;

    vkDriverLoadingTime.emplace_back(VK_DRIVER_LOADING_TIME_0);

    vkDriverLoadingTime.emplace_back(VK_DRIVER_LOADING_TIME_1);

    vkDriverLoadingTime.emplace_back(VK_DRIVER_LOADING_TIME_2);

    EXPECT_TRUE(event->write(int64VectorToProtoByteString(glDriverLoadingTime)));

    EXPECT_TRUE(event->write(int64VectorToProtoByteString(vkDriverLoadingTime)));

    event->init();

    inData.emplace_back(event);

    MockGpuStatsPuller mockPuller(android::util::GPU_STATS_APP_INFO, &inData);

    mockPuller.ForceClearCache();

    mockPuller.Pull(&outData);



    ASSERT_EQ(1, outData.size());

    EXPECT_EQ(android::util::GPU_STATS_APP_INFO, outData[0]->GetTagId());

    ASSERT_EQ(NUMBER_OF_VALUES_APP, outData[0]->size());

    EXPECT_EQ(APP_PACKAGE_NAME, outData[0]->getValues()[0].mValue.str_value);

    EXPECT_EQ(DRIVER_VERSION_CODE, outData[0]->getValues()[1].mValue.long_value);

    EXPECT_EQ(int64VectorToProtoByteString(glDriverLoadingTime),

              outData[0]->getValues()[2].mValue.str_value);

    EXPECT_EQ(int64VectorToProtoByteString(vkDriverLoadingTime),

              outData[0]->getValues()[3].mValue.str_value);

}



}  // namespace statsd

}  // namespace os

}  // namespace android

#else

GTEST_LOG_(INFO) << "This test does nothing.\n";

#endif