diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
index b744432..1f9917a 100644
--- a/test/openpower-pels/pel_test.cpp
+++ b/test/openpower-pels/pel_test.cpp
@@ -117,13 +117,21 @@
     regEntry.name = "test";
     regEntry.subsystem = 5;
     regEntry.actionFlags = 0xC000;
+    regEntry.src.type = 0xBD;
+    regEntry.src.reasonCode = 0x1234;
 
-    PEL pel{regEntry, 42, timestamp, phosphor::logging::Entry::Level::Error};
+    AdditionalData ad;
+
+    PEL pel{regEntry, 42, timestamp, phosphor::logging::Entry::Level::Error,
+            ad};
 
     EXPECT_TRUE(pel.valid());
     EXPECT_EQ(pel.privateHeader()->obmcLogID(), 42);
     EXPECT_EQ(pel.userHeader()->severity(), 0x40);
 
+    EXPECT_EQ(pel.primarySRC().value()->asciiString(),
+              "BD051234                        ");
+
     // Add more checks as more sections are added
 }
 
diff --git a/test/openpower-pels/pel_utils.cpp b/test/openpower-pels/pel_utils.cpp
index 4c94758..133e259 100644
--- a/test/openpower-pels/pel_utils.cpp
+++ b/test/openpower-pels/pel_utils.cpp
@@ -58,7 +58,7 @@
     0x00, 0x48,       // SRC structure size
 
     // Hex words 2 - 9
-    0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04,
+    0x02, 0x02, 0x02, 0x55, 0x03, 0x03, 0x03, 0x10, 0x04, 0x04, 0x04, 0x04,
     0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,
     0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09,
     // ASCII string
diff --git a/test/openpower-pels/src_test.cpp b/test/openpower-pels/src_test.cpp
index 7596186..abeda0b 100644
--- a/test/openpower-pels/src_test.cpp
+++ b/test/openpower-pels/src_test.cpp
@@ -26,8 +26,8 @@
     EXPECT_EQ(src.size(), 0x48);
 
     const auto& hexwords = src.hexwordData();
-    EXPECT_EQ(0x02020202, hexwords[0]);
-    EXPECT_EQ(0x03030303, hexwords[1]);
+    EXPECT_EQ(0x02020255, hexwords[0]);
+    EXPECT_EQ(0x03030310, hexwords[1]);
     EXPECT_EQ(0x04040404, hexwords[2]);
     EXPECT_EQ(0x05050505, hexwords[3]);
     EXPECT_EQ(0x06060606, hexwords[4]);
@@ -54,6 +54,7 @@
     SRC src{stream};
 
     EXPECT_TRUE(src.valid());
+    EXPECT_EQ(src.flags(), 0x01); // Additional sections within the SRC.
 
     // Spot check the SRC fields, but they're the same as above
     EXPECT_EQ(src.asciiString(), "BD8D5678                        ");
@@ -80,3 +81,67 @@
     src.flatten(newStream);
     EXPECT_EQ(data, newData);
 }
+
+// Create an SRC from the message registry
+TEST(SRCTest, CreateTestNoCallouts)
+{
+    message::Entry entry;
+    entry.src.type = 0xBD;
+    entry.src.reasonCode = 0xABCD;
+    entry.subsystem = 0x42;
+    entry.src.powerFault = true;
+    entry.src.hexwordADFields = {{5, "TEST1"}, // Not a user defined word
+                                 {6, "TEST1"},
+                                 {7, "TEST2"},
+                                 {8, "TEST3"},
+                                 {9, "TEST4"}};
+
+    // Values for the SRC words pointed to above
+    std::vector<std::string> adData{"TEST1=0x12345678", "TEST2=12345678",
+                                    "TEST3=0XDEF", "TEST4=Z"};
+    AdditionalData ad{adData};
+    SRC src{entry, ad};
+
+    EXPECT_TRUE(src.valid());
+    EXPECT_TRUE(src.isPowerFaultEvent());
+    EXPECT_EQ(src.size(), baseSRCSize);
+
+    const auto& hexwords = src.hexwordData();
+
+    // The spec always refers to SRC words 2 - 9, and as the hexwordData()
+    // array index starts at 0 use the math in the [] below to make it easier
+    // to tell what is being accessed.
+    EXPECT_EQ(hexwords[2 - 2] & 0xF0000000, 0);    // Partition dump status
+    EXPECT_EQ(hexwords[2 - 2] & 0x00F00000, 0);    // Partition boot type
+    EXPECT_EQ(hexwords[2 - 2] & 0x000000FF, 0x55); // SRC format
+    EXPECT_EQ(hexwords[3 - 2] & 0x000000FF, 0x10); // BMC position
+
+    // Validate more fields here as the code starts filling them in.
+
+    // Ensure hex word 5 wasn't allowed to be set to TEST1's contents
+    EXPECT_EQ(hexwords[5 - 2], 0);
+
+    // The user defined hex word fields specifed in the additional data.
+    EXPECT_EQ(hexwords[6 - 2], 0x12345678); // TEST1
+    EXPECT_EQ(hexwords[7 - 2], 12345678);   // TEST2
+    EXPECT_EQ(hexwords[8 - 2], 0xdef);      // TEST3
+    EXPECT_EQ(hexwords[9 - 2], 0);          // TEST4, but can't convert a 'Z'
+
+    EXPECT_EQ(src.asciiString(), "BD42ABCD                        ");
+
+    // No callouts
+    EXPECT_FALSE(src.callouts());
+
+    // May as well spot check the flatten/unflatten
+    std::vector<uint8_t> data;
+    Stream stream{data};
+    src.flatten(stream);
+
+    stream.offset(0);
+    SRC newSRC{stream};
+
+    EXPECT_TRUE(newSRC.valid());
+    EXPECT_EQ(newSRC.isPowerFaultEvent(), src.isPowerFaultEvent());
+    EXPECT_EQ(newSRC.asciiString(), src.asciiString());
+    EXPECT_FALSE(newSRC.callouts());
+}