diff --git a/test/openpower-pels/generic_section_test.cpp b/test/openpower-pels/generic_section_test.cpp
index 9fb6d9a..7cb9949 100644
--- a/test/openpower-pels/generic_section_test.cpp
+++ b/test/openpower-pels/generic_section_test.cpp
@@ -8,13 +8,13 @@
 TEST(GenericSectionTest, UnflattenFlattenTest)
 {
     // Use the private header data
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
 
-    Stream stream(*data);
+    Stream stream(data);
     Generic section(stream);
 
     EXPECT_EQ(section.header().id, 0x5048);
-    EXPECT_EQ(section.header().size, data->size());
+    EXPECT_EQ(section.header().size, data.size());
     EXPECT_EQ(section.header().version, 0x01);
     EXPECT_EQ(section.header().subType, 0x02);
     EXPECT_EQ(section.header().componentID, 0x0304);
@@ -22,11 +22,11 @@
     const auto& sectionData = section.data();
 
     // The data itself starts after the header
-    EXPECT_EQ(sectionData.size(), data->size() - 8);
+    EXPECT_EQ(sectionData.size(), data.size() - 8);
 
     for (size_t i = 0; i < sectionData.size(); i++)
     {
-        EXPECT_EQ(sectionData[i], (*data)[i + 8]);
+        EXPECT_EQ(sectionData[i], (data)[i + 8]);
     }
 
     // Now flatten
@@ -34,16 +34,16 @@
     Stream newStream(newData);
     section.flatten(newStream);
 
-    EXPECT_EQ(*data, newData);
+    EXPECT_EQ(data, newData);
 }
 
 TEST(GenericSectionTest, BadDataTest)
 {
     // Use the private header data to start with
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
-    data->resize(4);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
+    data.resize(4);
 
-    Stream stream(*data);
+    Stream stream(data);
     Generic section(stream);
     ASSERT_FALSE(section.valid());
 }
diff --git a/test/openpower-pels/pel_manager_test.cpp b/test/openpower-pels/pel_manager_test.cpp
index 61fbedd..9014dd8 100644
--- a/test/openpower-pels/pel_manager_test.cpp
+++ b/test/openpower-pels/pel_manager_test.cpp
@@ -34,11 +34,11 @@
 
     // Create a PEL, write it to a file, and pass that filename into
     // the create function.
-    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto data = pelDataFactory(TestPELType::pelSimple);
 
     fs::path pelFilename = makeTempDir() / "rawpel";
     std::ofstream pelFile{pelFilename};
-    pelFile.write(reinterpret_cast<const char*>(data->data()), data->size());
+    pelFile.write(reinterpret_cast<const char*>(data.data()), data.size());
     pelFile.close();
 
     std::string adItem = "RAWPEL=" + pelFilename.string();
diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
index 56e356f..b744432 100644
--- a/test/openpower-pels/pel_test.cpp
+++ b/test/openpower-pels/pel_test.cpp
@@ -17,9 +17,9 @@
 
 TEST_F(PELTest, FlattenTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
-    auto origData = *data;
-    auto pel = std::make_unique<PEL>(*data);
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto origData = data;
+    auto pel = std::make_unique<PEL>(data);
 
     // Check a few fields
     EXPECT_TRUE(pel->valid());
@@ -35,8 +35,8 @@
 
 TEST_F(PELTest, CommitTimeTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
-    auto pel = std::make_unique<PEL>(*data);
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto pel = std::make_unique<PEL>(data);
 
     auto origTime = pel->commitTime();
     pel->setCommitTime();
@@ -52,8 +52,8 @@
 
 TEST_F(PELTest, AssignIDTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
-    auto pel = std::make_unique<PEL>(*data);
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto pel = std::make_unique<PEL>(data);
 
     auto origID = pel->id();
     pel->assignID();
@@ -69,8 +69,8 @@
 
 TEST_F(PELTest, WithLogIDTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
-    auto pel = std::make_unique<PEL>(*data, 0x42);
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto pel = std::make_unique<PEL>(data, 0x42);
 
     EXPECT_TRUE(pel->valid());
     EXPECT_EQ(pel->obmcLogID(), 0x42);
@@ -78,21 +78,21 @@
 
 TEST_F(PELTest, InvalidPELTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto data = pelDataFactory(TestPELType::pelSimple);
 
     // Too small
-    data->resize(PrivateHeader::flattenedSize());
+    data.resize(PrivateHeader::flattenedSize());
 
-    auto pel = std::make_unique<PEL>(*data);
+    auto pel = std::make_unique<PEL>(data);
 
     EXPECT_TRUE(pel->privateHeader()->valid());
     EXPECT_FALSE(pel->userHeader()->valid());
     EXPECT_FALSE(pel->valid());
 
     // Now corrupt the private header
-    data = pelDataFactory(TestPelType::pelSimple);
-    data->at(0) = 0;
-    pel = std::make_unique<PEL>(*data);
+    data = pelDataFactory(TestPELType::pelSimple);
+    data.at(0) = 0;
+    pel = std::make_unique<PEL>(data);
 
     EXPECT_FALSE(pel->privateHeader()->valid());
     EXPECT_TRUE(pel->userHeader()->valid());
@@ -131,7 +131,7 @@
 // there aren't explicit classes for.
 TEST_F(PELTest, GenericSectionTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto data = pelDataFactory(TestPELType::pelSimple);
 
     std::vector<uint8_t> section1{0x58, 0x58, // ID 'XX'
                                   0x00, 0x18, // Size
@@ -154,14 +154,14 @@
         0x09, 0x22, 0x3A, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
 
     // Add the new sections at the end
-    data->insert(data->end(), section1.begin(), section1.end());
-    data->insert(data->end(), section2.begin(), section2.end());
+    data.insert(data.end(), section1.begin(), section1.end());
+    data.insert(data.end(), section2.begin(), section2.end());
 
     // Increment the section count
-    data->at(27) += 2;
-    auto origData = *data;
+    data.at(27) += 2;
+    auto origData = data;
 
-    PEL pel{*data};
+    PEL pel{data};
 
     const auto& sections = pel.optionalSections();
 
@@ -195,17 +195,17 @@
 // Test that an invalid section will still get a Generic object
 TEST_F(PELTest, InvalidGenericTest)
 {
-    auto data = pelDataFactory(TestPelType::pelSimple);
+    auto data = pelDataFactory(TestPELType::pelSimple);
 
     // Not a valid section
     std::vector<uint8_t> section1{0x01, 0x02, 0x03};
 
-    data->insert(data->end(), section1.begin(), section1.end());
+    data.insert(data.end(), section1.begin(), section1.end());
 
     // Increment the section count
-    data->at(27) += 1;
+    data.at(27) += 1;
 
-    PEL pel{*data};
+    PEL pel{data};
     EXPECT_FALSE(pel.valid());
 
     const auto& sections = pel.optionalSections();
diff --git a/test/openpower-pels/pel_utils.cpp b/test/openpower-pels/pel_utils.cpp
index 109c1ce..0af9bf5 100644
--- a/test/openpower-pels/pel_utils.cpp
+++ b/test/openpower-pels/pel_utils.cpp
@@ -15,15 +15,14 @@
 std::filesystem::path CleanPELFiles::repoPath{};
 std::filesystem::path CleanPELFiles::registryPath{};
 
-constexpr uint8_t simplePEL[] = {
-    // private header section header
+const std::vector<uint8_t> privateHeaderSection{
+    // section header
     0x50, 0x48, // ID 'PH'
     0x00, 0x30, // Size
     0x01, 0x02, // version, subtype
     0x03, 0x04, // comp ID
 
-    // private header
-    0x20, 0x30, 0x05, 0x09, 0x11, 0x1E, 0x1, 0x63,  // create timestamp
+    0x20, 0x30, 0x05, 0x09, 0x11, 0x1E, 0x1,  0x63, // create timestamp
     0x20, 0x31, 0x06, 0x0F, 0x09, 0x22, 0x3A, 0x00, // commit timestamp
     0xAA,                                           // creatorID
     0x00,                                           // logtype
@@ -32,58 +31,28 @@
     0x90, 0x91, 0x92, 0x93,                         // OpenBMC log ID
     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0,    // creator version
     0x50, 0x51, 0x52, 0x53,                         // plid
-    0x80, 0x81, 0x82, 0x83,                         // id
+    0x80, 0x81, 0x82, 0x83};
 
-    // user header section header
+const std::vector<uint8_t> userHeaderSection{
+    // section header
     0x55, 0x48, // ID 'UH'
     0x00, 0x18, // Size
     0x01, 0x0A, // version, subtype
     0x0B, 0x0C, // comp ID
 
-    // user header
     0x10, 0x04,             // subsystem, scope
     0x20, 0x00,             // severity, type
     0x00, 0x00, 0x00, 0x00, // reserved
     0x03, 0x04,             // problem domain, vector
     0x80, 0xC0,             // action flags
     0x00, 0x00, 0x00, 0x00  // reserved
-
-    // Add more as the code supports more
 };
 
-std::vector<uint8_t> srcFRUIdentityCallout{
-    'I', 'D', 0x1C, 0x1D,                     // type, size, flags
-    '1', '2', '3',  '4',                      // PN
-    '5', '6', '7',  0x00, 'A', 'A', 'A', 'A', // CCIN
-    '1', '2', '3',  '4',  '5', '6', '7', '8', // SN
-    '9', 'A', 'B',  'C'};
-
-std::vector<uint8_t> srcPCEIdentityCallout{
-    'P', 'E', 0x24, 0x00,                      // type, size, flags
-    'T', 'T', 'T',  'T',  '-', 'M', 'M',  'M', // MTM
-    '1', '2', '3',  '4',  '5', '6', '7',       // SN
-    '8', '9', 'A',  'B',  'C', 'P', 'C',  'E', // Name + null padded
-    'N', 'A', 'M',  'E',  '1', '2', 0x00, 0x00, 0x00};
-
-std::vector<uint8_t> srcMRUCallout{
-    'M',  'R',  0x28, 0x04, // ID, size, flags
-    0x00, 0x00, 0x00, 0x00, // Reserved
-    0x00, 0x00, 0x00, 'H',  // priority 0
-    0x01, 0x01, 0x01, 0x01, // MRU ID 0
-    0x00, 0x00, 0x00, 'M',  // priority 1
-    0x02, 0x02, 0x02, 0x02, // MRU ID 1
-    0x00, 0x00, 0x00, 'L',  // priority 2
-    0x03, 0x03, 0x03, 0x03, // MRU ID 2
-    0x00, 0x00, 0x00, 'H',  // priority 3
-    0x04, 0x04, 0x04, 0x04, // MRU ID 3
-};
-
-std::vector<uint8_t> srcSectionNoCallouts{
+const std::vector<uint8_t> srcSectionNoCallouts{
 
     // Header
     'P', 'S', 0x00, 0x80, 0x01, 0x01, 0x02, 0x02,
 
-    // SRC
     0x02, 0x00, 0x00, // version, flags, reserved
     0x09, 0x00, 0x00, // hex word count, reserved2B
     0x00, 0x48,       // SRC structure size
@@ -97,25 +66,89 @@
     ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
     ' ', ' '};
 
-std::unique_ptr<std::vector<uint8_t>> pelDataFactory(TestPelType type)
+const std::vector<uint8_t> srcFRUIdentityCallout{
+    'I', 'D', 0x1C, 0x1D,                     // type, size, flags
+    '1', '2', '3',  '4',                      // PN
+    '5', '6', '7',  0x00, 'A', 'A', 'A', 'A', // CCIN
+    '1', '2', '3',  '4',  '5', '6', '7', '8', // SN
+    '9', 'A', 'B',  'C'};
+
+const std::vector<uint8_t> srcPCEIdentityCallout{
+    'P', 'E', 0x24, 0x00,                      // type, size, flags
+    'T', 'T', 'T',  'T',  '-', 'M', 'M',  'M', // MTM
+    '1', '2', '3',  '4',  '5', '6', '7',       // SN
+    '8', '9', 'A',  'B',  'C', 'P', 'C',  'E', // Name + null padded
+    'N', 'A', 'M',  'E',  '1', '2', 0x00, 0x00, 0x00};
+
+const std::vector<uint8_t> srcMRUCallout{
+    'M',  'R',  0x28, 0x04, // ID, size, flags
+    0x00, 0x00, 0x00, 0x00, // Reserved
+    0x00, 0x00, 0x00, 'H',  // priority 0
+    0x01, 0x01, 0x01, 0x01, // MRU ID 0
+    0x00, 0x00, 0x00, 'M',  // priority 1
+    0x02, 0x02, 0x02, 0x02, // MRU ID 1
+    0x00, 0x00, 0x00, 'L',  // priority 2
+    0x03, 0x03, 0x03, 0x03, // MRU ID 2
+    0x00, 0x00, 0x00, 'H',  // priority 3
+    0x04, 0x04, 0x04, 0x04, // MRU ID 3
+};
+
+constexpr size_t sectionCountOffset = 27;
+
+std::vector<uint8_t> pelDataFactory(TestPELType type)
 {
-    std::unique_ptr<std::vector<uint8_t>> data;
+    std::vector<uint8_t> data;
+
     switch (type)
     {
-        case TestPelType::pelSimple:
-            data = std::make_unique<std::vector<uint8_t>>(
-                simplePEL, simplePEL + sizeof(simplePEL));
+        case TestPELType::pelSimple:
+            data.insert(data.end(), privateHeaderSection.begin(),
+                        privateHeaderSection.end());
+            data.insert(data.end(), userHeaderSection.begin(),
+                        userHeaderSection.end());
+            data.at(sectionCountOffset) = 2;
             break;
-        case TestPelType::privateHeaderSimple:
-            data = std::make_unique<std::vector<uint8_t>>(
-                simplePEL, simplePEL + PrivateHeader::flattenedSize());
+        case TestPELType::privateHeaderSection:
+            data.insert(data.end(), privateHeaderSection.begin(),
+                        privateHeaderSection.end());
             break;
-        case TestPelType::userHeaderSimple:
-            data = std::make_unique<std::vector<uint8_t>>(
-                simplePEL + PrivateHeader::flattenedSize(),
-                simplePEL + PrivateHeader::flattenedSize() +
-                    UserHeader::flattenedSize());
+        case TestPELType::userHeaderSection:
+            data.insert(data.end(), userHeaderSection.begin(),
+                        userHeaderSection.end());
             break;
+        case TestPELType::primarySRCSection:
+            data.insert(data.end(), srcSectionNoCallouts.begin(),
+                        srcSectionNoCallouts.end());
+            break;
+        case TestPELType::primarySRCSection2Callouts:
+        {
+            // Start with the no-callouts SRC, and add the callouts section
+            // from above.
+            auto src = srcSectionNoCallouts;
+            auto callouts =
+                srcDataFactory(TestSRCType::calloutSection2Callouts);
+
+            src.insert(src.end(), callouts.begin(), callouts.end());
+
+            // Set the flag that says there are callouts
+            // One byte after the 8B header
+            src[8 + 1] |= 0x01;
+
+            // Set the new sizes
+            uint16_t size = src.size();
+            Stream stream{src};
+
+            stream.offset(2); // In the header
+            stream << size;
+
+            // In the SRC - the size field doesn't include the header
+            size -= 8;
+            stream.offset(8 + 6);
+            stream << size;
+
+            data.insert(data.end(), src.begin(), src.end());
+            break;
+        }
     }
     return data;
 }
@@ -187,38 +220,6 @@
 
             return data;
         }
-        case TestSRCType::primarySRCNoCallouts:
-        {
-            return srcSectionNoCallouts;
-        }
-        case TestSRCType::primarySRC2Callouts:
-        {
-            // Start with the no-callouts SRC, and add the callouts section
-            // from above.
-            auto src = srcSectionNoCallouts;
-            auto callouts =
-                srcDataFactory(TestSRCType::calloutSection2Callouts);
-
-            src.insert(src.end(), callouts.begin(), callouts.end());
-
-            // Set the flag that says there are callouts
-            // One byte after the 8B header
-            src[8 + 1] |= 0x01;
-
-            // Set the new sizes
-            uint16_t size = src.size();
-            Stream stream{src};
-
-            stream.offset(2); // In the header
-            stream << size;
-
-            // In the SRC - the size field doesn't include the header
-            size -= 8;
-            stream.offset(8 + 6);
-            stream << size;
-
-            return src;
-        }
     }
     return {};
 }
diff --git a/test/openpower-pels/pel_utils.hpp b/test/openpower-pels/pel_utils.hpp
index 6d70dfa..fb608b8 100644
--- a/test/openpower-pels/pel_utils.hpp
+++ b/test/openpower-pels/pel_utils.hpp
@@ -52,11 +52,13 @@
 /**
  * @brief Tells the factory which PEL to create
  */
-enum class TestPelType
+enum class TestPELType
 {
     pelSimple,
-    privateHeaderSimple,
-    userHeaderSimple
+    privateHeaderSection,
+    userHeaderSection,
+    primarySRCSection,
+    primarySRCSection2Callouts
 };
 
 /**
@@ -69,9 +71,7 @@
     mruStructure,
     calloutStructureA,
     calloutStructureB,
-    calloutSection2Callouts,
-    primarySRCNoCallouts,
-    primarySRC2Callouts
+    calloutSection2Callouts
 };
 
 /**
@@ -79,9 +79,9 @@
  *
  * @param[in] type - the type of data to create
  *
- * @return std::unique_ptr<std::vector<uint8_t>> - the PEL data
+ * @return std::vector<uint8_t> - the PEL data
  */
-std::unique_ptr<std::vector<uint8_t>> pelDataFactory(TestPelType type);
+std::vector<uint8_t> pelDataFactory(TestPELType type);
 
 /**
  * @brief SRC data factory, for testing
diff --git a/test/openpower-pels/private_header_test.cpp b/test/openpower-pels/private_header_test.cpp
index ebb515c..07746b3 100644
--- a/test/openpower-pels/private_header_test.cpp
+++ b/test/openpower-pels/private_header_test.cpp
@@ -16,9 +16,9 @@
 
 TEST_F(PrivateHeaderTest, UnflattenFlattenTest)
 {
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
 
-    Stream stream(*data);
+    Stream stream(data);
     PrivateHeader ph(stream);
     EXPECT_EQ(ph.valid(), true);
 
@@ -65,7 +65,7 @@
     Stream newStream(newData);
 
     ph.flatten(newStream);
-    EXPECT_EQ(*data, newData);
+    EXPECT_EQ(data, newData);
 
     // Change a field, then flatten and unflatten again
     ph.creatorID() = 0x55;
@@ -73,7 +73,7 @@
     newStream.offset(0);
     newData.clear();
     ph.flatten(newStream);
-    EXPECT_NE(*data, newData);
+    EXPECT_NE(data, newData);
 
     newStream.offset(0);
     PrivateHeader newPH(newStream);
@@ -84,9 +84,9 @@
 
 TEST_F(PrivateHeaderTest, ShortDataTest)
 {
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
-    data->resize(PrivateHeader::flattenedSize() - 1);
-    Stream stream(*data);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
+    data.resize(PrivateHeader::flattenedSize() - 1);
+    Stream stream(data);
 
     PrivateHeader ph(stream);
 
@@ -95,10 +95,10 @@
 
 TEST_F(PrivateHeaderTest, CorruptDataTest1)
 {
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
-    Stream stream(*data);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
+    Stream stream(data);
 
-    data->at(0) = 0; // corrupt the section ID
+    data.at(0) = 0; // corrupt the section ID
 
     PrivateHeader ph(stream);
 
@@ -107,10 +107,10 @@
 
 TEST_F(PrivateHeaderTest, CorruptDataTest2)
 {
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
-    Stream stream(*data);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
+    Stream stream(data);
 
-    data->at(4) = 0x22; // corrupt the version
+    data.at(4) = 0x22; // corrupt the version
 
     PrivateHeader ph(stream);
 
@@ -119,10 +119,10 @@
 
 TEST_F(PrivateHeaderTest, CorruptDataTest3)
 {
-    auto data = pelDataFactory(TestPelType::privateHeaderSimple);
-    Stream stream(*data);
+    auto data = pelDataFactory(TestPELType::privateHeaderSection);
+    Stream stream(data);
 
-    data->at(27) = 1; // corrupt the section count
+    data.at(27) = 1; // corrupt the section count
 
     PrivateHeader ph(stream);
 
diff --git a/test/openpower-pels/repository_test.cpp b/test/openpower-pels/repository_test.cpp
index 57952e3..85ceab6 100644
--- a/test/openpower-pels/repository_test.cpp
+++ b/test/openpower-pels/repository_test.cpp
@@ -54,8 +54,8 @@
 TEST_F(RepositoryTest, AddTest)
 {
     Repository repo{repoPath};
-    auto data = pelDataFactory(TestPelType::pelSimple);
-    auto pel = std::make_unique<PEL>(*data);
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto pel = std::make_unique<PEL>(data);
 
     repo.add(pel);
 
@@ -84,15 +84,15 @@
 
         // Add some PELs to the repository
         {
-            auto data = pelDataFactory(TestPelType::pelSimple);
-            auto pel = std::make_unique<PEL>(*data, 1);
+            auto data = pelDataFactory(TestPELType::pelSimple);
+            auto pel = std::make_unique<PEL>(data, 1);
             pel->assignID();
             repo.add(pel);
             ids.emplace_back(pelID(pel->id()), obmcID(1));
         }
         {
-            auto data = pelDataFactory(TestPelType::pelSimple);
-            auto pel = std::make_unique<PEL>(*data, 2);
+            auto data = pelDataFactory(TestPELType::pelSimple);
+            auto pel = std::make_unique<PEL>(data, 2);
             pel->assignID();
             repo.add(pel);
             ids.emplace_back(pelID(pel->id()), obmcID(2));
@@ -149,9 +149,9 @@
     EXPECT_FALSE(noData);
 
     // Add a PEL to the repo, and get the data back with getPELData.
-    auto data = pelDataFactory(TestPelType::pelSimple);
-    auto dataCopy = *data;
-    auto pel = std::make_unique<PEL>(*data);
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto dataCopy = data;
+    auto pel = std::make_unique<PEL>(data);
     auto pelID = pel->id();
     repo.add(pel);
 
diff --git a/test/openpower-pels/src_test.cpp b/test/openpower-pels/src_test.cpp
index 7af3306..7596186 100644
--- a/test/openpower-pels/src_test.cpp
+++ b/test/openpower-pels/src_test.cpp
@@ -7,7 +7,7 @@
 
 TEST(SRCTest, UnflattenFlattenTestNoCallouts)
 {
-    auto data = srcDataFactory(TestSRCType::primarySRCNoCallouts);
+    auto data = pelDataFactory(TestPELType::primarySRCSection);
 
     Stream stream{data};
     SRC src{stream};
@@ -48,7 +48,7 @@
 
 TEST(SRCTest, UnflattenFlattenTest2Callouts)
 {
-    auto data = srcDataFactory(TestSRCType::primarySRC2Callouts);
+    auto data = pelDataFactory(TestPELType::primarySRCSection2Callouts);
 
     Stream stream{data};
     SRC src{stream};
diff --git a/test/openpower-pels/user_header_test.cpp b/test/openpower-pels/user_header_test.cpp
index d3eedfc..88ac9a5 100644
--- a/test/openpower-pels/user_header_test.cpp
+++ b/test/openpower-pels/user_header_test.cpp
@@ -15,9 +15,9 @@
 
 TEST(UserHeaderTest, UnflattenFlattenTest)
 {
-    auto data = pelDataFactory(TestPelType::userHeaderSimple);
+    auto data = pelDataFactory(TestPELType::userHeaderSection);
 
-    Stream stream(*data);
+    Stream stream(data);
     UserHeader uh(stream);
     EXPECT_EQ(uh.valid(), true);
 
@@ -41,7 +41,7 @@
     Stream newStream(newData);
 
     uh.flatten(newStream);
-    EXPECT_EQ(*data, newData);
+    EXPECT_EQ(data, newData);
 
     // Change a field, then flatten and unflatten again
     uh.subsystem() = 0x44;
@@ -49,7 +49,7 @@
     newStream.offset(0);
     newData.clear();
     uh.flatten(newStream);
-    EXPECT_NE(*data, newData);
+    EXPECT_NE(data, newData);
 
     newStream.offset(0);
     UserHeader newUH(newStream);
@@ -60,10 +60,10 @@
 
 TEST(UserHeaderTest, ShortDataTest)
 {
-    auto data = pelDataFactory(TestPelType::userHeaderSimple);
-    data->resize(data->size() - 1);
+    auto data = pelDataFactory(TestPELType::userHeaderSection);
+    data.resize(data.size() - 1);
 
-    Stream stream(*data);
+    Stream stream(data);
     UserHeader uh(stream);
 
     EXPECT_EQ(uh.valid(), false);
@@ -71,12 +71,12 @@
 
 TEST(UserHeaderTest, CorruptDataTest1)
 {
-    auto data = pelDataFactory(TestPelType::userHeaderSimple);
-    data->resize(data->size() - 1);
+    auto data = pelDataFactory(TestPELType::userHeaderSection);
+    data.resize(data.size() - 1);
 
-    data->at(0) = 0; // corrupt the section ID
+    data.at(0) = 0; // corrupt the section ID
 
-    Stream stream(*data);
+    Stream stream(data);
     UserHeader uh(stream);
 
     EXPECT_EQ(uh.valid(), false);
@@ -84,11 +84,11 @@
 
 TEST(UserHeaderTest, CorruptDataTest2)
 {
-    auto data = pelDataFactory(TestPelType::userHeaderSimple);
+    auto data = pelDataFactory(TestPELType::userHeaderSection);
 
-    data->at(4) = 0x22; // corrupt the version
+    data.at(4) = 0x22; // corrupt the version
 
-    Stream stream(*data);
+    Stream stream(data);
     UserHeader uh(stream);
 
     EXPECT_EQ(uh.valid(), false);