diff --git a/src/test/propertygentest.cpp b/src/test/propertygentest.cpp
new file mode 100644
index 0000000..cf32191
--- /dev/null
+++ b/src/test/propertygentest.cpp
@@ -0,0 +1,156 @@
+#include <array>
+#include <string>
+#include <gtest/gtest.h>
+#include "data_types.hpp"
+
+using namespace std::string_literals;
+using namespace phosphor::dbus::monitoring;
+
+using Property =
+    TupleOfRefs <
+    const std::string,
+    const std::string,
+    const std::string >;
+
+using GroupOfProperties = std::vector<Property>;
+
+#include "propertygentest.hpp"
+const std::array<std::string, 3> expectedMeta =
+{
+    "property1"s,
+    "property2"s,
+    "property3"s,
+};
+
+const std::array<std::string, 4> expectedInterfaces =
+{
+    "xyz.openbmc_project.Test.Iface3"s,
+    "xyz.openbmc_project.Test.Iface2"s,
+    "xyz.openbmc_project.Test.Iface6"s,
+    "xyz.openbmc_project.Test.Iface1"s,
+};
+
+const std::array<std::string, 4> expectedProperties =
+{
+    "Foo"s,
+    "Value"s,
+    "Bar"s,
+    "Baz"s,
+};
+
+const std::array<GroupOfProperties, 4> expectedGroups =
+{
+    {
+        {
+            Property{ interfaces[0], properties[0], meta[0] },
+            Property{ interfaces[1], properties[1], meta[1] },
+        },
+        {
+            Property{ interfaces[0], properties[2], meta[0] },
+            Property{ interfaces[1], properties[0], meta[1] },
+        },
+        {
+            Property{ interfaces[2], properties[0], meta[0] },
+            Property{ interfaces[3], properties[1], meta[1] },
+        },
+        {
+            Property{ interfaces[0], properties[2], meta[0] },
+            Property{ interfaces[1], properties[1], meta[1] },
+            Property{ interfaces[2], properties[3], meta[2] },
+        },
+    }
+};
+
+const std::array<std::string, 4> expectedTypes =
+{
+    "uint32_t"s,
+    "int32_t"s,
+    "std::string"s,
+    "int32_t"s,
+};
+
+TEST(PropertyGenTest, MetaSameSize)
+{
+    ASSERT_EQ(sizeof(expectedMeta), sizeof(meta));
+}
+
+TEST(PropertyGenTest, IfacesSameSize)
+{
+    ASSERT_EQ(sizeof(expectedInterfaces), sizeof(interfaces));
+}
+
+TEST(PropertyGenTest, PropertiesSameSize)
+{
+    ASSERT_EQ(sizeof(expectedProperties), sizeof(properties));
+}
+
+TEST(PropertyGenTest, GroupsSameSize)
+{
+    ASSERT_EQ(sizeof(expectedGroups), sizeof(groups));
+}
+
+TEST(PropertyGenTest, TypesSameSize)
+{
+    ASSERT_EQ(sizeof(expectedTypes), sizeof(types));
+}
+
+TEST(PropertyGenTest, MetaSameContent)
+{
+    size_t i;
+    for (i = 0; i < expectedMeta.size(); ++i)
+    {
+        ASSERT_EQ(meta[i],
+                  expectedMeta[i]);
+    }
+}
+
+TEST(PropertyGenTest, IfacesSameContent)
+{
+    size_t i;
+    for (i = 0; i < expectedInterfaces.size(); ++i)
+    {
+        ASSERT_EQ(interfaces[i],
+                  expectedInterfaces[i]);
+    }
+}
+
+TEST(PropertyGenTest, PropertiesSameContent)
+{
+    size_t i;
+    for (i = 0; i < expectedProperties.size(); ++i)
+    {
+        ASSERT_EQ(expectedProperties[i], properties[i]);
+    }
+}
+
+TEST(PropertyGenTest, GroupsSameContent)
+{
+    size_t i;
+    for (i = 0; i < expectedGroups.size(); ++i)
+    {
+        size_t j;
+        for (j = 0; j < expectedGroups[i].size(); ++j)
+        {
+            const auto& expectedIface = std::get<0>(expectedGroups[i][j]).get();
+            const auto& actualIface = std::get<0>(groups[i][j]).get();
+            ASSERT_EQ(expectedIface, actualIface);
+
+            const auto& expectedProperty = std::get<1>(expectedGroups[i][j]).get();
+            const auto& actualProperty = std::get<1>(groups[i][j]).get();
+            ASSERT_EQ(expectedProperty, actualProperty);
+
+            const auto& expectedMeta = std::get<1>(expectedGroups[i][j]).get();
+            const auto& actualMeta = std::get<1>(groups[i][j]).get();
+            ASSERT_EQ(expectedMeta, actualMeta);
+        }
+    }
+}
+
+TEST(PropertyGenTest, TypesSameContent)
+{
+    size_t i;
+    for (i = 0; i < expectedTypes.size(); ++i)
+    {
+        ASSERT_EQ(expectedTypes[i], types[i]);
+    }
+}