[2746] Add option to ignore duplicates (and clear them)

src/lib/log/message_initializer.cc

@@ -67,7 +67,7 @@ MessageInitializer::getPendingCount() {
 // into the global dictionary.
 
 void
-MessageInitializer::loadDictionary() {
+MessageInitializer::loadDictionary(bool ignore_duplicates) {
     MessageDictionary& global = MessageDictionary::globalDictionary();
 
     for (size_t i = 0; i < getIndex(); ++i) {
@@ -75,7 +75,7 @@ MessageInitializer::loadDictionary() {
 
         // Append the IDs in the list just loaded (the "repeats") to the
         // global list of duplicate IDs.
-        if (!repeats.empty()) {
+        if (!ignore_duplicates && !repeats.empty()) {
             std::vector<std::string>& duplicates = getDuplicates();
             duplicates.insert(duplicates.end(), repeats.begin(),
                               repeats.end());
@@ -89,11 +89,15 @@ MessageInitializer::loadDictionary() {
 }
 
 // Return reference to duplicate array
-
 std::vector<std::string>& MessageInitializer::getDuplicates() {
     static std::vector<std::string> duplicates;
     return (duplicates);
 }
 
+// Clear the duplicate array
+void MessageInitializer::clearDuplicates() {
+    getDuplicates().clear();
+}
+
 } // namespace log
 } // namespace isc

src/lib/log/message_initializer.h

@@ -93,7 +93,7 @@ public:
     /// Loops through the internal array of pointers to message arrays
     /// and adds the messages to the internal dictionary.  This is called
     /// during run-time initialization.
-    static void loadDictionary();
+    static void loadDictionary(bool ignore_duplicates = false);
 
     /// \brief Return Duplicates
     ///
@@ -103,6 +103,11 @@ public:
     /// \return List of duplicate message IDs when the global dictionary was
     /// loaded.  Note that the duplicates list itself may contain duplicates.
     static std::vector<std::string>& getDuplicates();
+
+    /// \brief Clear the static duplicates vector
+    ///
+    /// Empties the vector returned by getDuplicates
+    static void clearDuplicates();
 };
 
 } // namespace log

src/lib/log/tests/message_initializer_1_unittest.cc

@@ -77,3 +77,38 @@ TEST(MessageInitializerTest1, MessageTest) {
     EXPECT_EQ(string("global message five"), global.getText("GLOBAL5"));
     EXPECT_EQ(string("global message six"), global.getText("GLOBAL6"));
 }
+
+TEST(MessageInitializerTest1, Duplicates) {
+    // Original set should not have dupes
+    ASSERT_EQ(0, MessageInitializer::getDuplicates().size());
+
+    // This just defines 1, but we'll add it a number of times
+    const char* dupe[] = {
+        "DUPE", "dupe",
+        NULL
+    };
+    const MessageInitializer init_message_initializer_unittest_1(dupe);
+    const MessageInitializer init_message_initializer_unittest_2(dupe);
+
+    MessageInitializer::loadDictionary();
+    // Should be a dupe now
+    ASSERT_EQ(1, MessageInitializer::getDuplicates().size());
+
+    // clear them
+    MessageInitializer::clearDuplicates();
+    ASSERT_EQ(0, MessageInitializer::getDuplicates().size());
+
+    // Do it again to make sure, let's explicitely provide false now
+    const MessageInitializer init_message_initializer_unittest_3(dupe);
+    MessageInitializer::loadDictionary(false);
+    ASSERT_EQ(1, MessageInitializer::getDuplicates().size());
+
+    // Loading with ignore_duplicates=true should result in no (reported)
+    // dupes
+    MessageInitializer::clearDuplicates();
+    ASSERT_EQ(0, MessageInitializer::getDuplicates().size());
+    const MessageInitializer init_message_initializer_unittest_4(dupe);
+    MessageInitializer::loadDictionary(true);
+    ASSERT_EQ(0, MessageInitializer::getDuplicates().size());
+}
+