diff --git a/test/message/append.cpp b/test/message/append.cpp
index e753b01..8e0e558 100644
--- a/test/message/append.cpp
+++ b/test/message/append.cpp
@@ -90,6 +90,18 @@
         EXPECT_CALL(mock, sd_bus_message_close_container(nullptr))
             .WillOnce(Return(0));
     }
+
+    static int on_array_append(sd_bus_message*, char, const void*, size_t)
+    {
+        return 0;
+    }
+
+    void expect_append_array(char type, size_t sz)
+    {
+        EXPECT_CALL(mock,
+                    sd_bus_message_append_array(nullptr, type, testing::_, sz))
+            .WillOnce(testing::Invoke(on_array_append));
+    }
 };
 
 TEST_F(AppendTest, RValueInt)
@@ -253,13 +265,7 @@
         !sdbusplus::message::details::can_append_multiple_v<decltype(a)>);
 
     {
-        testing::InSequence seq;
-        expect_open_container(SD_BUS_TYPE_ARRAY, "d");
-        for (const auto& i : a)
-        {
-            expect_basic<double>(SD_BUS_TYPE_DOUBLE, i);
-        }
-        expect_close_container();
+        expect_append_array(SD_BUS_TYPE_DOUBLE, a.size() * sizeof(double));
     }
     new_message().append(a);
 }
@@ -272,13 +278,7 @@
         !sdbusplus::message::details::can_append_multiple_v<decltype(s)>);
 
     {
-        testing::InSequence seq;
-        expect_open_container(SD_BUS_TYPE_ARRAY, "d");
-        for (const auto& i : s)
-        {
-            expect_basic<double>(SD_BUS_TYPE_DOUBLE, i);
-        }
-        expect_close_container();
+        expect_append_array(SD_BUS_TYPE_DOUBLE, a.size() * sizeof(double));
     }
     new_message().append(s);
 }
@@ -299,6 +299,31 @@
     new_message().append(v);
 }
 
+TEST_F(AppendTest, VectorIntegral)
+{
+    const std::vector<int32_t> v{1, 2, 3, 4};
+    expect_append_array(SD_BUS_TYPE_INT32, v.size() * sizeof(int32_t));
+    new_message().append(v);
+}
+
+TEST_F(AppendTest, VectorNestIntegral)
+{
+    const std::vector<std::array<int32_t, 3>> v{
+        {1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
+
+    {
+        testing::InSequence seq;
+        expect_open_container(SD_BUS_TYPE_ARRAY, "ai");
+        for (long unsigned int i = 0; i < v.size(); i++)
+        {
+            expect_append_array(SD_BUS_TYPE_INT32,
+                                v[i].size() * sizeof(int32_t));
+        }
+        expect_close_container();
+    }
+    new_message().append(v);
+}
+
 TEST_F(AppendTest, Set)
 {
     const std::set<std::string> s{"one", "two", "eight"};
diff --git a/test/message/read.cpp b/test/message/read.cpp
index a70fd3b..581f7d0 100644
--- a/test/message/read.cpp
+++ b/test/message/read.cpp
@@ -21,6 +21,8 @@
 {
 
 using testing::DoAll;
+using testing::ElementsAre;
+using testing::Invoke;
 using testing::Return;
 using testing::StrEq;
 
@@ -62,6 +64,26 @@
             .WillOnce(DoAll(AssignReadVal<T>(val), Return(0)));
     }
 
+    template <typename T>
+    static void read_array_callback(sd_bus_message*, char, const void** p,
+                                    size_t* sz)
+    {
+        static const std::array<T, 3> arr{std::numeric_limits<T>::min(), 0,
+                                          std::numeric_limits<T>::max()};
+
+        *p = arr.data();
+        *sz = arr.size() * sizeof(T);
+    }
+
+    template <typename T>
+    void expect_read_array(char type)
+    {
+        EXPECT_CALL(mock, sd_bus_message_read_array(nullptr, type, testing::_,
+                                                    testing::_))
+            .WillOnce(
+                DoAll(testing::Invoke(read_array_callback<T>), Return(0)));
+    }
+
     void expect_verify_type(char type, const char* contents, int ret)
     {
         EXPECT_CALL(mock,
@@ -243,6 +265,56 @@
     EXPECT_EQ(vs, ret_vs);
 }
 
+TEST_F(ReadTest, VectorUnsignedIntegral8)
+{
+    expect_read_array<uint8_t>(SD_BUS_TYPE_BYTE);
+    std::vector<uint8_t> ret_vi;
+    new_message().read(ret_vi);
+    EXPECT_THAT(ret_vi, ElementsAre(0, 0, 255));
+}
+
+TEST_F(ReadTest, VectorIntegral32)
+{
+    expect_read_array<int32_t>(SD_BUS_TYPE_INT32);
+    std::vector<int32_t> ret_vi;
+    new_message().read(ret_vi);
+    EXPECT_THAT(ret_vi, ElementsAre(-2147483648, 0, 2147483647));
+}
+
+TEST_F(ReadTest, VectorIntegral64)
+{
+    expect_read_array<int64_t>(SD_BUS_TYPE_INT64);
+    std::vector<int64_t> ret_vi;
+    new_message().read(ret_vi);
+    EXPECT_THAT(ret_vi, ElementsAre(-9223372036854775807LL - 1, 0,
+                                    9223372036854775807LL));
+}
+
+TEST_F(ReadTest, VectorUnsignedIntegral32)
+{
+    expect_read_array<uint32_t>(SD_BUS_TYPE_UINT32);
+    std::vector<uint32_t> ret_vi;
+    new_message().read(ret_vi);
+    EXPECT_THAT(ret_vi, ElementsAre(0, 0, 4294967295));
+}
+
+TEST_F(ReadTest, VectorUnsignedIntegral64)
+{
+    expect_read_array<uint64_t>(SD_BUS_TYPE_UINT64);
+    std::vector<uint64_t> ret_vi;
+    new_message().read(ret_vi);
+    EXPECT_THAT(ret_vi, ElementsAre(0, 0, 18446744073709551615ULL));
+}
+
+TEST_F(ReadTest, VectorDouble)
+{
+    expect_read_array<double>(SD_BUS_TYPE_DOUBLE);
+    std::vector<double> ret_vi;
+    new_message().read(ret_vi);
+    EXPECT_THAT(ret_vi, ElementsAre(2.2250738585072014e-308, 0,
+                                    1.7976931348623157e+308));
+}
+
 TEST_F(ReadTest, VectorEnterError)
 {
     {