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

Commit 7f6fa2e1 authored by Yu Shan's avatar Yu Shan Committed by Automerger Merge Worker
Browse files

Improve test coverage for FakeValueGenerator. am: 83fe8052 

Original change: https://googleplex-android-review.googlesource.com/c/platform/hardware/interfaces/+/16997312

Change-Id: If05bc4b421da8e43cb02e0c154489e8954c78288
parents c63fc7a0 83fe8052

automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ filegroup { 
    name: "FakeVehicleHalValueGeneratorsTestFiles",

    srcs: [

        "prop.json",

        "prop_different_types.json",

        "prop_invalid.json",

    ],

}

automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/FakeVehicleHalValueGeneratorsTest.cpp

+114 −51
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <utils/SystemClock.h>



#include <chrono>

#include <condition_variable>

#include <memory>

#include <mutex>

#include <optional>
@@ -38,6 +39,9 @@ namespace fake { 


using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;

using ::aidl::android::hardware::automotive::vehicle::VehiclePropValue;

using ::android::base::ScopedLockAssertion;



using std::literals::chrono_literals::operator""s;



class FakeVehicleHalValueGeneratorsTest : public ::testing::Test {

  protected:
@@ -58,6 +62,16 @@ class FakeVehicleHalValueGeneratorsTest : public ::testing::Test { 
        mEvents.clear();

    }



    void waitForEvents(size_t count) {

        std::unique_lock<std::mutex> uniqueLock(mEventsLock);

        bool result = mCv.wait_for(uniqueLock, 10s, [this, count] {

            ScopedLockAssertion lockAssertion(mEventsLock);

            return mEvents.size() == count;

        });



        ASSERT_TRUE(result) << "didn't receive enough events";

    }



    void TearDown() override {

        // Generator callback uses mEvents, must stop generator before destroying mEvents.

        mHub.reset();
@@ -71,12 +85,16 @@ class FakeVehicleHalValueGeneratorsTest : public ::testing::Test { 
  private:

    void onHalEvent(const VehiclePropValue& event) {

        VehiclePropValue eventCopy = event;

        {

            std::scoped_lock<std::mutex> lockGuard(mEventsLock);

            mEvents.push_back(std::move(eventCopy));

        }

        mCv.notify_all();

    }



    std::unique_ptr<GeneratorHub> mHub;

    std::mutex mEventsLock;

    std::condition_variable mCv;

    std::vector<VehiclePropValue> mEvents GUARDED_BY(mEventsLock);

};
@@ -115,8 +133,7 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testRegisterTestFakeValueGenerator) { 


    getHub()->registerGenerator(0, std::move(generator));



    // All the events require 500ms to generate, so waiting for 1000ms should be enough.

    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    waitForEvents(events.size());



    ASSERT_EQ(getEvents(), events);
@@ -137,11 +154,12 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testUnregisterGeneratorStopGeneration) 
    generator->setEvents(events);



    getHub()->registerGenerator(0, std::move(generator));

    getHub()->unregisterGenerator(0);



    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    waitForEvents(1);



    getHub()->unregisterGenerator(0);



    ASSERT_LT(getEvents().size(), static_cast<size_t>(10))

    ASSERT_LE(getEvents().size(), 2u)

            << "Must stop generating event after generator is unregistered";

}
@@ -155,13 +173,12 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testLinerFakeValueGeneratorFloat) { 
                                                       /*interval=*/10000000);

    getHub()->registerGenerator(0, std::move(generator));



    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    waitForEvents(10);

    auto events = getEvents();

    // We should get 10 events ideally, but let's be safe here.

    ASSERT_LE((size_t)5, events.size());



    ASSERT_EQ(events.size(), 10u);

    int value = 30;

    for (size_t i = 0; i < 5; i++) {

    for (size_t i = 0; i < 10; i++) {

        EXPECT_EQ(std::vector<float>({static_cast<float>(value)}), events[i].value.floatValues);

        value = (value + 20) % 100;

    }
@@ -177,13 +194,11 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testLinerFakeValueGeneratorInt32) { 
                                                       /*interval=*/10000000);

    getHub()->registerGenerator(0, std::move(generator));



    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    waitForEvents(10);

    auto events = getEvents();

    // We should get 10 events ideally, but let's be safe here.

    ASSERT_LE((size_t)5, events.size());

    ASSERT_EQ(events.size(), 10u);

    int value = 30;

    for (size_t i = 0; i < 5; i++) {

    for (size_t i = 0; i < 10; i++) {

        EXPECT_EQ(std::vector<int32_t>({value}), events[i].value.int32Values);

        value = (value + 20) % 100;

    }
@@ -199,13 +214,12 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testLinerFakeValueGeneratorInt64) { 
                                                       /*interval=*/10000000);

    getHub()->registerGenerator(0, std::move(generator));



    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    waitForEvents(10);

    auto events = getEvents();

    // We should get 10 events ideally, but let's be safe here.

    ASSERT_LE((size_t)5, events.size());

    ASSERT_EQ(events.size(), 10u);

    int value = 30;

    for (size_t i = 0; i < 5; i++) {

    for (size_t i = 0; i < 10; i++) {

        EXPECT_EQ(std::vector<int64_t>({value}), events[i].value.int64Values);

        value = (value + 20) % 100;

    }
@@ -221,13 +235,11 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testLinerFakeValueGeneratorUsingReques 
            std::make_unique<LinearFakeValueGenerator>(request);

    getHub()->registerGenerator(0, std::move(generator));



    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    waitForEvents(10);

    auto events = getEvents();

    // We should get 10 events ideally, but let's be safe here.

    ASSERT_LE((size_t)5, events.size());

    ASSERT_EQ(events.size(), 10u);

    int value = 50;

    for (size_t i = 0; i < 5; i++) {

    for (size_t i = 0; i < 10; i++) {

        EXPECT_EQ(std::vector<float>({static_cast<float>(value)}), events[i].value.floatValues);

        value = (value + 20) % 100;

    }
@@ -244,15 +256,13 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testLinerFakeValueGeneratorInvalidInit 
                                                       /*interval=*/10000000);

    getHub()->registerGenerator(0, std::move(generator));



    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    waitForEvents(10);

    auto events = getEvents();

    // We should get 10 events ideally, but let's be safe here.

    ASSERT_LE((size_t)5, events.size());

    ASSERT_EQ(events.size(), 10u);



    // Init value would be set to middleValue if given initValue is not valid.

    int value = 50;

    for (size_t i = 0; i < 5; i++) {

    for (size_t i = 0; i < 10; i++) {

        EXPECT_EQ(std::vector<float>({static_cast<float>(value)}), events[i].value.floatValues);

        value = (value + 20) % 100;

    }
@@ -265,9 +275,6 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGenerator) { 
            std::make_unique<JsonFakeValueGenerator>(getTestFilePath("prop.json"), 2);

    getHub()->registerGenerator(0, std::move(generator));



    // wait for some time.

    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    std::vector<VehiclePropValue> expectedValues = {

            VehiclePropValue{

                    .areaId = 0,
@@ -296,6 +303,7 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGenerator) { 
        expectedValues.push_back(expectedValues[i]);

    }



    waitForEvents(expectedValues.size());

    auto events = getEvents();



    long lastEventTime = currentTime;
@@ -313,14 +321,7 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorIterateIndef 
            std::make_unique<JsonFakeValueGenerator>(getTestFilePath("prop.json"), -1);

    getHub()->registerGenerator(0, std::move(generator));



    // wait for some time.

    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    auto events = getEvents();



    // Send 1 iteration takes 4ms + 1ms interval between iteration, so for 100ms we should get about

    // 20 iteration, which is 80 events.

    EXPECT_GT(events.size(), static_cast<size_t>(50));

    waitForEvents(40);

}



TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorUsingRequest) {
@@ -335,9 +336,6 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorUsingRequest 
            std::make_unique<JsonFakeValueGenerator>(request);

    getHub()->registerGenerator(0, std::move(generator));



    // wait for some time.

    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    std::vector<VehiclePropValue> expectedValues = {

            VehiclePropValue{

                    .areaId = 0,
@@ -366,6 +364,7 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorUsingRequest 
        expectedValues.push_back(expectedValues[i]);

    }



    waitForEvents(expectedValues.size());

    auto events = getEvents();



    long lastEventTime = currentTime;
@@ -388,9 +387,6 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorInvalidFile) 
            std::make_unique<JsonFakeValueGenerator>(request);

    getHub()->registerGenerator(0, std::move(generator));



    // wait for some time.

    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    ASSERT_TRUE(getEvents().empty());

}
@@ -404,12 +400,79 @@ TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorNonExistingF 
            std::make_unique<JsonFakeValueGenerator>(request);

    getHub()->registerGenerator(0, std::move(generator));



    // wait for some time.

    std::this_thread::sleep_for(std::chrono::milliseconds(100));



    ASSERT_TRUE(getEvents().empty());

}



TEST_F(FakeVehicleHalValueGeneratorsTest, testJsonFakeValueGeneratorDifferentTypes) {

    std::unique_ptr<JsonFakeValueGenerator> generator = std::make_unique<JsonFakeValueGenerator>(

            getTestFilePath("prop_different_types.json"), 1);

    getHub()->registerGenerator(0, std::move(generator));



    std::vector<VehiclePropValue> expectedValues = {

            VehiclePropValue{

                    .areaId = 0,

                    .value.int32Values = {1},

                    .prop = 287310600,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value.int32Values = {2},

                    .prop = 289408000,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value.floatValues = {3.3},

                    .prop = 291504905,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value.int64Values = {4},

                    .prop = 290457096,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value.stringValue = "test",

                    .prop = 286265094,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value.int32Values = {1, 2},

                    .prop = 289476368,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value =

                            {

                                    .int32Values = {1, 2},

                                    .int64Values = {3, 4},

                                    .floatValues = {5.5, 6.6},

                                    .stringValue = "test",

                            },

                    .prop = 299896626,

            },

            VehiclePropValue{

                    .areaId = 0,

                    .value =

                            {

                                    .int32Values = {1},

                                    .floatValues = {1.0},

                                    .byteValues = {0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,

                                                   0x00, 0x00, 0x00, 0x00, 0x00},

                            },

                    .prop = 299896064,

            },

    };



    waitForEvents(expectedValues.size());

    auto events = getEvents();



    for (auto& event : events) {

        event.timestamp = 0;

    }



    EXPECT_EQ(events, expectedValues);

}



}  // namespace fake

}  // namespace vehicle

}  // namespace automotive

automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/prop_different_types.json

0 → 100644
+58 −0
Original line number Diff line number Diff line 
[

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": 1,

    "prop": 287310600

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": 2,

    "prop": 289408000

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": 3.3,

    "prop": 291504905

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": 4,

    "prop": 290457096

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": "test",

    "prop": 286265094

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": [1, 2],

    "prop": 289476368

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": {

      "int32Values": [1, 2],

      "int64Values": [3, 4],

      "floatValues": [5.5, 6.6],

      "stringValue": "test"

    },

    "prop": 299896626

  },

  {

    "timestamp": 1000000,

    "areaId": 0,

    "value": {

      "int32Values": [1],

      "floatValues": [1]

    },

    "prop": 299896064

  }

]
 
 No newline at end of file

automotive/vehicle/aidl/impl/utils/common/test/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ package { 
}



cc_test {

    name: "VehicleHalVehicleUtilsVendorTest",

    name: "VehicleHalVehicleUtilsTest",

    srcs: ["*.cpp"],

    vendor: true,

    static_libs: [