Parameterize VtsEvsHalV1_1TargetTest

#define LOG_TAG "VtsHalEvsTest"

// Note:  We have't got a great way to indicate which target

// should be tested, so we'll leave the interface served by the

// default (mock) EVS driver here for easy reference.  All

// actual EVS drivers should serve on the EvsEnumeratorHw name,

// however, so the code is checked in that way.

//const static char kEnumeratorName[]  = "EvsEnumeratorHw-Mock";

const static char kEnumeratorName[]  = "EvsEnumeratorHw";

// These values are called out in the EVS design doc (as of Mar 8, 2017)

static const int kMaxStreamStartMilliseconds = 500;

static const int kMinimumFramesPerSecond = 10;

#include <ui/DisplayConfig.h>

#include <ui/DisplayState.h>

#include <VtsHalHidlTargetTestBase.h>

#include <VtsHalHidlTargetTestEnvBase.h>

#include <gtest/gtest.h>

#include <hidl/GtestPrinter.h>

#include <hidl/ServiceManagement.h>

using namespace ::android::hardware::automotive::evs::V1_1;

using namespace std::chrono_literals;

using ::android::hardware::Return;

using ::android::hardware::Void;

} RawStreamConfig;

// Test environment for Evs HIDL HAL.

class EvsHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {

   public:

    // get the test environment singleton

    static EvsHidlEnvironment* Instance() {

        static EvsHidlEnvironment* instance = new EvsHidlEnvironment;

        return instance;

    }

    virtual void registerTestServices() override { registerTestService<IEvsEnumerator>(); }

   private:

    EvsHidlEnvironment() {}

};

// The main test class for EVS

class EvsHidlTest : public ::testing::VtsHalHidlTargetTestBase {

class EvsHidlTest : public ::testing::TestWithParam<std::string> {

public:

    virtual void SetUp() override {

        // Make sure we can connect to the enumerator

        string service_name =

            EvsHidlEnvironment::Instance()->getServiceName<IEvsEnumerator>(kEnumeratorName);

        pEnumerator = getService<IEvsEnumerator>(service_name);

        std::string service_name = GetParam();

        pEnumerator = IEvsEnumerator::getService(service_name);

        ASSERT_NE(pEnumerator.get(), nullptr);

        mIsHwModule = pEnumerator->isHardware();

 * Opens each camera reported by the enumerator and then explicitly closes it via a

 * call to closeCamera.  Then repeats the test to ensure all cameras can be reopened.

 */

TEST_F(EvsHidlTest, CameraOpenClean) {

TEST_P(EvsHidlTest, CameraOpenClean) {

    ALOGI("Starting CameraOpenClean test");

    // Get the camera list

 * call.  This ensures that the intended "aggressive open" behavior works.  This is necessary for

 * the system to be tolerant of shutdown/restart race conditions.

 */

TEST_F(EvsHidlTest, CameraOpenAggressive) {

TEST_P(EvsHidlTest, CameraOpenAggressive) {

    ALOGI("Starting CameraOpenAggressive test");

    // Get the camera list

 * CameraStreamPerformance:

 * Measure and qualify the stream start up time and streaming frame rate of each reported camera

 */

TEST_F(EvsHidlTest, CameraStreamPerformance) {

TEST_P(EvsHidlTest, CameraStreamPerformance) {

    ALOGI("Starting CameraStreamPerformance test");

    // Get the camera list

 * Ensure the camera implementation behaves properly when the client holds onto buffers for more

 * than one frame time.  The camera must cleanly skip frames until the client is ready again.

 */

TEST_F(EvsHidlTest, CameraStreamBuffering) {

TEST_P(EvsHidlTest, CameraStreamBuffering) {

    ALOGI("Starting CameraStreamBuffering test");

    // Arbitrary constant (should be > 1 and less than crazy)

 * imagery is simply copied to the display buffer and presented on screen.  This is the one test

 * which a human could observe to see the operation of the system on the physical display.

 */

TEST_F(EvsHidlTest, CameraToDisplayRoundTrip) {

TEST_P(EvsHidlTest, CameraToDisplayRoundTrip) {

    ALOGI("Starting CameraToDisplayRoundTrip test");

    // Get the camera list

 * Verify that each client can start and stop video streams on the same

 * underlying camera.

 */

TEST_F(EvsHidlTest, MultiCameraStream) {

TEST_P(EvsHidlTest, MultiCameraStream) {

    ALOGI("Starting MultiCameraStream test");

    if (mIsHwModule) {

 * CameraParameter:

 * Verify that a client can adjust a camera parameter.

 */

TEST_F(EvsHidlTest, CameraParameter) {

TEST_P(EvsHidlTest, CameraParameter) {

    ALOGI("Starting CameraParameter test");

    // Get the camera list

 * Verify that non-master client gets notified when the master client either

 * terminates or releases a role.

 */

TEST_F(EvsHidlTest, CameraMasterRelease) {

TEST_P(EvsHidlTest, CameraMasterRelease) {

    ALOGI("Starting CameraMasterRelease test");

    if (mIsHwModule) {

 * Verify that master and non-master clients behave as expected when they try to adjust

 * camera parameters.

 */

TEST_F(EvsHidlTest, MultiCameraParameter) {

TEST_P(EvsHidlTest, MultiCameraParameter) {

    ALOGI("Starting MultiCameraParameter test");

    if (mIsHwModule) {

        std::mutex eventLock;

        auto timer = std::chrono::system_clock::now();

        unique_lock<std::mutex> lock(eventLock);

        std::unique_lock<std::mutex> lock(eventLock);

        while (!listening) {

            eventCond.wait_until(lock, timer + 1s);

        }

 * EVS client, which owns the display, is priortized and therefore can take over

 * a master role from other EVS clients without the display.

 */

TEST_F(EvsHidlTest, HighPriorityCameraClient) {

TEST_P(EvsHidlTest, HighPriorityCameraClient) {

    ALOGI("Starting HighPriorityCameraClient test");

    if (mIsHwModule) {

 * CameraToDisplayRoundTrip test case but this case retrieves available stream

 * configurations from EVS and uses one of them to start a video stream.

 */

TEST_F(EvsHidlTest, CameraUseStreamConfigToDisplay) {

TEST_P(EvsHidlTest, CameraUseStreamConfigToDisplay) {

    ALOGI("Starting CameraUseStreamConfigToDisplay test");

    // Get the camera list

 * Verify that each client can start and stop video streams on the same

 * underlying camera with same configuration.

 */

TEST_F(EvsHidlTest, MultiCameraStreamUseConfig) {

TEST_P(EvsHidlTest, MultiCameraStreamUseConfig) {

    ALOGI("Starting MultiCameraStream test");

    if (mIsHwModule) {

 * checking its capability and locating supporting physical camera device

 * identifiers.

 */

TEST_F(EvsHidlTest, LogicalCameraMetadata) {

TEST_P(EvsHidlTest, LogicalCameraMetadata) {

    ALOGI("Starting LogicalCameraMetadata test");

    // Get the camera list

 * call to closeUltrasonicsArray. Then repeats the test to ensure all ultrasonics arrays

 * can be reopened.

 */

TEST_F(EvsHidlTest, UltrasonicsArrayOpenClean) {

TEST_P(EvsHidlTest, UltrasonicsArrayOpenClean) {

    ALOGI("Starting UltrasonicsArrayOpenClean test");

    // Get the ultrasonics array list

// Starts a stream and verifies all data received is valid.

TEST_F(EvsHidlTest, UltrasonicsVerifyStreamData) {

TEST_P(EvsHidlTest, UltrasonicsVerifyStreamData) {

    ALOGI("Starting UltrasonicsVerifyStreamData");

    // Get the ultrasonics array list

// Sets frames in flight before and after start of stream and verfies success.

TEST_F(EvsHidlTest, UltrasonicsSetFramesInFlight) {

TEST_P(EvsHidlTest, UltrasonicsSetFramesInFlight) {

    ALOGI("Starting UltrasonicsSetFramesInFlight");

    // Get the ultrasonics array list

}

int main(int argc, char** argv) {

    ::testing::AddGlobalTestEnvironment(EvsHidlEnvironment::Instance());

    ::testing::InitGoogleTest(&argc, argv);

    EvsHidlEnvironment::Instance()->init(&argc, argv);

    int status = RUN_ALL_TESTS();

    ALOGI("Test result = %d", status);

    return status;

}

INSTANTIATE_TEST_SUITE_P(

    PerInstance,

    EvsHidlTest,

    testing::ValuesIn(android::hardware::getAllHalInstanceNames(IEvsEnumerator::descriptor)),

    android::hardware::PrintInstanceNameToString);