diff --git a/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/Android.bp b/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/Android.bp
index ac8db44..2eef13c 100644
--- a/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/Android.bp
+++ b/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/Android.bp
@@ -41,6 +41,7 @@
     name: "FakeVehicleHalValueGeneratorsTestFiles",
     srcs: [
         "prop.json",
+        "prop_different_types.json",
         "prop_invalid.json",
     ],
 }
diff --git a/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/FakeVehicleHalValueGeneratorsTest.cpp b/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/FakeVehicleHalValueGeneratorsTest.cpp
index 21aa680..674b078 100644
--- a/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/FakeVehicleHalValueGeneratorsTest.cpp
+++ b/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/FakeVehicleHalValueGeneratorsTest.cpp
@@ -24,6 +24,7 @@
 #include <utils/SystemClock.h>
 
 #include <chrono>
+#include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -38,6 +39,9 @@
 
 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 @@
         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 @@
   private:
     void onHalEvent(const VehiclePropValue& event) {
         VehiclePropValue eventCopy = event;
-        std::scoped_lock<std::mutex> lockGuard(mEventsLock);
-        mEvents.push_back(std::move(eventCopy));
+        {
+            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 @@
 
     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 @@
     generator->setEvents(events);
 
     getHub()->registerGenerator(0, std::move(generator));
+
+    waitForEvents(1);
+
     getHub()->unregisterGenerator(0);
 
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-
-    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 @@
                                                        /*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 @@
                                                        /*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 @@
                                                        /*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 @@
             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 @@
                                                        /*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 @@
             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 @@
         expectedValues.push_back(expectedValues[i]);
     }
 
+    waitForEvents(expectedValues.size());
     auto events = getEvents();
 
     long lastEventTime = currentTime;
@@ -313,14 +321,7 @@
             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 @@
             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 @@
         expectedValues.push_back(expectedValues[i]);
     }
 
+    waitForEvents(expectedValues.size());
     auto events = getEvents();
 
     long lastEventTime = currentTime;
@@ -388,9 +387,6 @@
             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 @@
             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
diff --git a/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/prop_different_types.json b/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/prop_different_types.json
new file mode 100644
index 0000000..0363ebd
--- /dev/null
+++ b/automotive/vehicle/aidl/impl/fake_impl/GeneratorHub/test/prop_different_types.json
@@ -0,0 +1,58 @@
+[
+  {
+    "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
diff --git a/automotive/vehicle/aidl/impl/utils/common/test/Android.bp b/automotive/vehicle/aidl/impl/utils/common/test/Android.bp
index 5b41ff4..250b331 100644
--- a/automotive/vehicle/aidl/impl/utils/common/test/Android.bp
+++ b/automotive/vehicle/aidl/impl/utils/common/test/Android.bp
@@ -19,7 +19,7 @@
 }
 
 cc_test {
-    name: "VehicleHalVehicleUtilsVendorTest",
+    name: "VehicleHalVehicleUtilsTest",
     srcs: ["*.cpp"],
     vendor: true,
     static_libs: [