Merge branch 'develop' into feature/issue698

src/json.hpp

@@ -3497,23 +3497,18 @@ class primitive_iterator_t
     /// return whether the iterator can be dereferenced
     constexpr bool is_begin() const noexcept
     {
-        return (m_it == begin_value);
+        return m_it == begin_value;
     }
 
     /// return whether the iterator is at end
     constexpr bool is_end() const noexcept
     {
-        return (m_it == end_value);
+        return m_it == end_value;
     }
 
     friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
     {
-        return (lhs.m_it == rhs.m_it);
+        return lhs.m_it == rhs.m_it;
-    }
-
-    friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return not(lhs == rhs);
     }
 
     friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
@@ -3521,21 +3516,6 @@ class primitive_iterator_t
         return lhs.m_it < rhs.m_it;
     }
 
-    friend constexpr bool operator<=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return lhs.m_it <= rhs.m_it;
-    }
-
-    friend constexpr bool operator>(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return lhs.m_it > rhs.m_it;
-    }
-
-    friend constexpr bool operator>=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-    {
-        return lhs.m_it >= rhs.m_it;
-    }
-
     primitive_iterator_t operator+(difference_type i)
     {
         auto result = *this;
@@ -3596,7 +3576,7 @@ class primitive_iterator_t
     static constexpr difference_type end_value = begin_value + 1;
 
     /// iterator as signed integer type
-    difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
+    difference_type m_it = std::numeric_limits<std::ptrdiff_t>::min();
 };
 
 /*!
@@ -9045,7 +9025,7 @@ class basic_json
     @liveexample{The following code exemplifies `type()` for all JSON
     types.,type}
 
-    @sa @ref operator value_t() -- return the type of the JSON value (implicit) 
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
     @sa @ref type_name() -- return the type as string
 
     @since version 1.0.0
@@ -13086,7 +13066,7 @@ class basic_json
     types.,type_name}
 
     @sa @ref type() -- return the type of the JSON value
-    @sa @ref operator value_t() -- return the type of the JSON value (implicit) 
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
 
     @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
     since 3.0.0

test/src/unit-deserialization.cpp

@@ -324,7 +324,7 @@ TEST_CASE("deserialization")
                 uint8_t v[] = {'\"', 0x7F, 0xDF, 0x7F};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                 CHECK_THROWS_WITH(json::parse(std::begin(v), std::end(v)),
-                    "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
+                                  "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
                 CHECK(not json::accept(std::begin(v), std::end(v)));
 
                 json j_error;

test/src/unit-iterators1.cpp

@@ -225,6 +225,114 @@ TEST_CASE("iterators 1")
                 CHECK(*it == j_const);
             }
 
+            SECTION("additional tests")
+            {
+                SECTION("!(begin != begin)")
+                {
+                    CHECK(not(j.begin() != j.begin()));
+                }
+
+                SECTION("!(end != end)")
+                {
+                    CHECK(not(j.end() != j.end()));
+                }
+
+                SECTION("begin < end")
+                {
+                    CHECK(j.begin() < j.end());
+                }
+
+                SECTION("begin <= end")
+                {
+                    CHECK(j.begin() <= j.end());
+                }
+
+                SECTION("end > begin")
+                {
+                    CHECK(j.end() > j.begin());
+                }
+
+                SECTION("end >= begin")
+                {
+                    CHECK(j.end() >= j.begin());
+                }
+
+                SECTION("end == end")
+                {
+                    CHECK(j.end() == j.end());
+                }
+
+                SECTION("end <= end")
+                {
+                    CHECK(j.end() <= j.end());
+                }
+
+                SECTION("begin == begin")
+                {
+                    CHECK(j.begin() == j.begin());
+                }
+
+                SECTION("begin <= begin")
+                {
+                    CHECK(j.begin() <= j.begin());
+                }
+
+                SECTION("begin >= begin")
+                {
+                    CHECK(j.begin() >= j.begin());
+                }
+
+                SECTION("!(begin == end)")
+                {
+                    CHECK(not(j.begin() == j.end()));
+                }
+
+                SECTION("begin != end")
+                {
+                    CHECK(j.begin() != j.end());
+                }
+
+                SECTION("begin+1 == end")
+                {
+                    CHECK(j.begin() + 1 == j.end());
+                }
+
+                SECTION("begin == end-1")
+                {
+                    CHECK(j.begin() == j.end() - 1);
+                }
+
+                SECTION("begin != end+1")
+                {
+                    CHECK(j.begin() != j.end() + 1);
+                }
+
+                SECTION("end != end+1")
+                {
+                    CHECK(j.end() != j.end() + 1);
+                }
+
+                SECTION("begin+1 != begin+2")
+                {
+                    CHECK(j.begin() + 1 != j.begin() + 2);
+                }
+
+                SECTION("begin+1 < begin+2")
+                {
+                    CHECK(j.begin() + 1 < j.begin() + 2);
+                }
+
+                SECTION("begin+1 <= begin+2")
+                {
+                    CHECK(j.begin() + 1 <= j.begin() + 2);
+                }
+
+                SECTION("end+1 != end+2")
+                {
+                    CHECK(j.end() + 1 != j.end() + 2);
+                }
+            }
+
             SECTION("key/value")
             {
                 auto it = j.begin();