diff --git a/test/openpower-pels/pel_test.cpp b/test/openpower-pels/pel_test.cpp
index a996358..cf54e9c 100644
--- a/test/openpower-pels/pel_test.cpp
+++ b/test/openpower-pels/pel_test.cpp
@@ -958,7 +958,8 @@
     ffdcFile.version = 1;
 
     // Write these callouts to a JSON file and pass it into
-    // the PEL as an FFDC file.
+    // the PEL as an FFDC file. Also has a duplicate that
+    // will be removed.
     auto inputJSON = R"([
         {
             "Priority": "H",
@@ -967,6 +968,10 @@
         {
             "Priority": "M",
             "Procedure": "PROCEDURE"
+        },
+        {
+            "Priority": "L",
+            "Procedure": "PROCEDURE"
         }
     ])"_json;
 
diff --git a/test/openpower-pels/src_callout_test.cpp b/test/openpower-pels/src_callout_test.cpp
index daa2ab6..a03b9b0 100644
--- a/test/openpower-pels/src_callout_test.cpp
+++ b/test/openpower-pels/src_callout_test.cpp
@@ -432,3 +432,128 @@
         }
     }
 }
+
+TEST(CalloutTest, OperatorEqualTest)
+{
+    {
+        Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
+                   "123456789ABC"};
+        Callout c2{CalloutPriority::high, "A1", "1234567", "ABCD",
+                   "123456789ABC"};
+        EXPECT_EQ(c1, c2);
+    }
+
+    {
+        // Different location code
+        Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
+                   "123456789ABC"};
+        Callout c2{CalloutPriority::high, "A2", "1234567", "ABCD",
+                   "123456789ABC"};
+        EXPECT_NE(c1, c2);
+    }
+
+    {
+        // maintenance procedure
+        Callout c1{CalloutPriority::medium, "bmc_code"};
+        Callout c2{CalloutPriority::medium, "bmc_code"};
+        EXPECT_EQ(c1, c2);
+    }
+
+    {
+        // different maintenance procedures
+        Callout c1{CalloutPriority::medium, "bmc_code"};
+        Callout c2{CalloutPriority::medium, "sbe_code"};
+        EXPECT_NE(c1, c2);
+    }
+
+    {
+        // symbolic FRU
+        Callout c1{CalloutPriority::high, "service_docs", "", false};
+        Callout c2{CalloutPriority::high, "service_docs", "", false};
+        EXPECT_EQ(c1, c2);
+    }
+
+    {
+        // different symbolic FRUs
+        Callout c1{CalloutPriority::high, "service_docs", "", false};
+        Callout c2{CalloutPriority::high, "air_mover", "", false};
+        EXPECT_NE(c1, c2);
+    }
+
+    {
+        // HW callout vs symbolic FRU
+        Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
+                   "123456789ABC"};
+        Callout c2{CalloutPriority::high, "service_docs", "", false};
+        EXPECT_NE(c1, c2);
+    }
+
+    {
+        // HW callout vs maintenance procedure
+        Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
+                   "123456789ABC"};
+        Callout c2{CalloutPriority::medium, "bmc_code"};
+        EXPECT_NE(c1, c2);
+    }
+
+    {
+        // symbolic FRU vs maintenance procedure
+        Callout c1{CalloutPriority::high, "service_docs", "", false};
+        Callout c2{CalloutPriority::medium, "bmc_code"};
+        EXPECT_NE(c1, c2);
+    }
+
+    {
+        // HW callout vs symbolic FRU is still considered equal if
+        // the location code is the same
+        Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
+                   "123456789ABC"};
+        Callout c2{CalloutPriority::high, "service_docs", "A1", true};
+        EXPECT_EQ(c1, c2);
+    }
+}
+
+TEST(CalloutTest, OperatorGreaterThanTest)
+{
+    {
+        Callout c1{CalloutPriority::high, "bmc_code"};
+        Callout c2{CalloutPriority::medium, "bmc_code"};
+        EXPECT_TRUE(c1 > c2);
+    }
+    {
+        Callout c1{CalloutPriority::high, "bmc_code"};
+        Callout c2{CalloutPriority::low, "bmc_code"};
+        EXPECT_TRUE(c1 > c2);
+    }
+    {
+        Callout c1{CalloutPriority::medium, "bmc_code"};
+        Callout c2{CalloutPriority::low, "bmc_code"};
+        EXPECT_TRUE(c1 > c2);
+    }
+    {
+        Callout c1{CalloutPriority::mediumGroupA, "bmc_code"};
+        Callout c2{CalloutPriority::low, "bmc_code"};
+        EXPECT_TRUE(c1 > c2);
+    }
+    {
+        Callout c1{CalloutPriority::medium, "bmc_code"};
+        Callout c2{CalloutPriority::high, "bmc_code"};
+        EXPECT_FALSE(c1 > c2);
+    }
+    {
+        Callout c1{CalloutPriority::high, "bmc_code"};
+        Callout c2{CalloutPriority::high, "bmc_code"};
+        EXPECT_FALSE(c1 > c2);
+    }
+    {
+        Callout c1{CalloutPriority::low, "bmc_code"};
+        Callout c2{CalloutPriority::high, "bmc_code"};
+        EXPECT_FALSE(c1 > c2);
+    }
+    {
+        // Treat the different mediums the same
+        Callout c1{CalloutPriority::medium, "bmc_code"};
+        Callout c2{CalloutPriority::mediumGroupA, "bmc_code"};
+        EXPECT_FALSE(c1 > c2);
+    }
+}
diff --git a/test/openpower-pels/src_callouts_test.cpp b/test/openpower-pels/src_callouts_test.cpp
index 69c26b8..f13462d 100644
--- a/test/openpower-pels/src_callouts_test.cpp
+++ b/test/openpower-pels/src_callouts_test.cpp
@@ -16,6 +16,8 @@
 #include "extensions/openpower-pels/callouts.hpp"
 #include "pel_utils.hpp"
 
+#include <format>
+
 #include <gtest/gtest.h>
 
 using namespace openpower::pels;
@@ -99,8 +101,9 @@
 
     for (size_t i = 0; i < maxNumberOfCallouts; i++)
     {
+        auto loc = std::format("U1-P{}", i);
         auto callout = std::make_unique<Callout>(
-            CalloutPriority::high, "U1-P1", "1234567", "ABCD", "123456789ABC");
+            CalloutPriority::high, loc, "1234567", "ABCD", "123456789ABC");
         auto calloutSize = callout->flattenedSize();
 
         callouts.addCallout(std::move(callout));
@@ -200,3 +203,65 @@
     EXPECT_EQ(calloutObjects[9]->locationCode(), "U1-P10");
     EXPECT_EQ(calloutObjects[9]->priority(), 'L');
 }
+
+TEST(CalloutsTest, TestDupCallouts)
+{
+    {
+        // Duplicate callouts, keep the high priority one
+        Callouts callouts;
+        auto c0 = std::make_unique<Callout>(CalloutPriority::medium, "U1-P1",
+                                            "1234567", "ABC", "123456789ABC");
+        callouts.addCallout(std::move(c0));
+
+        auto c1 = std::make_unique<Callout>(CalloutPriority::high, "U1-P1",
+                                            "1234567", "ABCD", "123456789ABC");
+        callouts.addCallout(std::move(c1));
+
+        EXPECT_EQ(callouts.callouts().size(), 1);
+        const auto& calloutObjects = callouts.callouts();
+        EXPECT_EQ(calloutObjects[0]->priority(), 'H');
+    }
+
+    {
+        // Different callouts, keep them both
+        Callouts callouts;
+        auto c0 = std::make_unique<Callout>(CalloutPriority::high, "U1-P1",
+                                            "1234567", "ABC", "123456789ABC");
+        callouts.addCallout(std::move(c0));
+
+        auto c1 = std::make_unique<Callout>(CalloutPriority::medium, "U1-P2",
+                                            "1234567", "ABCD", "123456789ABC");
+        callouts.addCallout(std::move(c1));
+
+        EXPECT_EQ(callouts.callouts().size(), 2);
+    }
+
+    {
+        // Two duplicates and two unique.  Needs sorting.
+        Callouts callouts;
+        auto c0 = std::make_unique<Callout>(CalloutPriority::low, "U1-P9",
+                                            "1234567", "ABCD", "123456789ABC");
+        callouts.addCallout(std::move(c0));
+
+        auto c1 = std::make_unique<Callout>(CalloutPriority::low, "U1-P1",
+                                            "1234567", "ABC", "123456789ABC");
+        callouts.addCallout(std::move(c1));
+
+        auto c2 = std::make_unique<Callout>(CalloutPriority::high, "U1-P1",
+                                            "1234567", "ABC", "123456789ABC");
+        callouts.addCallout(std::move(c2));
+
+        auto c3 = std::make_unique<Callout>(CalloutPriority::medium, "U1-P5",
+                                            "1234567", "ABCD", "123456789ABC");
+        callouts.addCallout(std::move(c3));
+
+        const auto& calloutObjects = callouts.callouts();
+        EXPECT_EQ(callouts.callouts().size(), 3);
+        EXPECT_EQ(calloutObjects[0]->priority(), 'H');
+        EXPECT_EQ(calloutObjects[0]->locationCode(), "U1-P1");
+        EXPECT_EQ(calloutObjects[1]->priority(), 'M');
+        EXPECT_EQ(calloutObjects[1]->locationCode(), "U1-P5");
+        EXPECT_EQ(calloutObjects[2]->priority(), 'L');
+        EXPECT_EQ(calloutObjects[2]->locationCode(), "U1-P9");
+    }
+}