lib: adding == and != for uhd::dict

3 files changed, 71 insertions, 0 deletions

diff --git a/host/include/uhd/types/dict.hpp b/host/include/uhd/types/dict.hpp
index b8537a3c2..51594e17b 100644
--- a/host/include/uhd/types/dict.hpp
+++ b/host/include/uhd/types/dict.hpp
@@ -100,6 +100,20 @@ namespace uhd{
         Val &operator[](const Key &key);
 
         /*!
+         * Equals operator for the dict type
+         * \param other the dict being compared to this
+         * \return whether or not the two dict's are equal
+         */
+        bool operator==(const dict<Key, Val> &other) const;
+
+        /*!
+         * Not equal operator for the dict type
+         * \param other the dict being compared to this
+         * \return whether or not the two dict's are not equal
+         */
+        bool operator!=(const dict<Key, Val> &other) const;
+
+        /*!
          * Pop an item out of the dictionary.
          * \param key the item key
          * \return the value of the item
diff --git a/host/include/uhd/types/dict.ipp b/host/include/uhd/types/dict.ipp
index 26de1f08e..9ff64ee2b 100644
--- a/host/include/uhd/types/dict.ipp
+++ b/host/include/uhd/types/dict.ipp
@@ -113,6 +113,24 @@ namespace uhd{
     }
 
     template <typename Key, typename Val>
+    bool dict<Key, Val>::operator==(const dict<Key, Val> &other) const{
+        if (this->size() != other.size()){
+            return false;
+        }
+        for(auto &p : _map){
+            if (not (other.has_key(p.first) and other.get(p.first) == p.second)){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    template <typename Key, typename Val>
+    bool dict<Key, Val>::operator!=(const dict<Key, Val> &other) const{
+        return not (*this == other);
+    }
+
+    template <typename Key, typename Val>
     Val dict<Key, Val>::pop(const Key &key){
         typename std::list<pair_t>::iterator it;
         for (it = _map.begin(); it != _map.end(); it++){
diff --git a/host/tests/dict_test.cpp b/host/tests/dict_test.cpp
index 6b0285b8a..53432d533 100644
--- a/host/tests/dict_test.cpp
+++ b/host/tests/dict_test.cpp
@@ -84,4 +84,43 @@ BOOST_AUTO_TEST_CASE(test_dict_update)
     BOOST_CHECK_THROW(d3.update(d2), uhd::value_error);
 }
 
+BOOST_AUTO_TEST_CASE(test_dict_equals)
+{
+    typedef uhd::dict<std::string, std::string> dict_ss;
+    // Original dict
+    dict_ss d0;
+    d0["key1"] = "val1";
+    d0["key2"] = "val2";
+    // Same keys and vals as d1, but different order
+    dict_ss d1;
+    d1["key2"] = "val2";
+    d1["key1"] = "val1";
+    // Same vals, different keys
+    dict_ss d2;
+    d2["key1"] = "val1";
+    d2["key3"] = "val2";
+    // Same keys, different vals
+    dict_ss d3;
+    d3["key1"] = "val1";
+    d3["key2"] = "val3";
+    // Superset of d0
+    dict_ss d4;
+    d4["key1"] = "val1";
+    d4["key2"] = "val2";
+    d4["key4"] = "val3";
+    // Subset of d0
+    dict_ss d5;
+    d5["key1"] = "val1";
 
+    // Check that d0 and d1 are equal
+    BOOST_CHECK(d0 == d1);
+    BOOST_CHECK(d1 == d0);
+    // Check that all other dictionaries are not equal to d0
+    BOOST_CHECK(d0 != d2);
+    BOOST_CHECK(d0 != d3);
+    BOOST_CHECK(d0 != d4);
+    BOOST_CHECK(d0 != d5);
+    // Redundant, but just to be sure
+    BOOST_CHECK(not (d0 == d2));
+    BOOST_CHECK(not (d0 == d3));
+}