From dd2b534de41616654bb8f95c44ce18cf236813c1 Mon Sep 17 00:00:00 2001
From: Chris Fretz <cfretz@bloomberg.net>
Date: Tue, 3 Mar 2020 14:20:33 -0500
Subject: [PATCH] Extended dart::string/dart::number API Added implicit
 conversions and operators to make them behave more like their native
 counterparts

---
 include/dart.h                   | 156 ++++++++++++++++++++++++++++---
 include/dart/api.tcc             |  18 ++--
 include/dart/common.h            |   7 +-
 include/dart/conversion_traits.h |   8 +-
 include/dart/heap/string.tcc     |  25 ++---
 include/dart/operators.tcc       |  54 +++++++++++
 include/dart/packet/string.tcc   |   4 +-
 include/dart/primitive.tcc       |  58 ++++++++++++
 include/dart/string.tcc          |   8 ++
 test/operator_unit_tests.cc      | 120 ++++++++++++++++++++++++
 10 files changed, 419 insertions(+), 39 deletions(-)

diff --git a/include/dart.h b/include/dart.h
index 946aad8..98abb9d 100644
--- a/include/dart.h
+++ b/include/dart.h
@@ -3333,6 +3333,24 @@ namespace dart {
       >
       basic_string() : basic_string("") {}
 
+      /**
+       *  @brief
+       *  Constructor can be used to directly initialize a strongly
+       *  typed string with an initial value.
+       *
+       *  @details
+       *  Internally calls make_string on the underlying packet type
+       *  (if implemented).
+       */
+      template <class Str = String, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_string_t, Str, std::string const&>::value
+        >
+      >
+      explicit basic_string(std::string const& str) :
+        val(value_type::make_string(str))
+      {}
+
       /**
        *  @brief
        *  Constructor can be used to directly initialize a strongly
@@ -3351,6 +3369,40 @@ namespace dart {
         val(value_type::make_string(str))
       {}
 
+      /**
+       *  @brief
+       *  Constructor can be used to directly initialize a strongly
+       *  typed string with an initial value.
+       *
+       *  @details
+       *  Internally calls make_string on the underlying packet type
+       *  (if implemented).
+       */
+      template <class Str = String, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_string_t, Str, char const*>::value
+        >
+      >
+      basic_string(char const* str) :
+        val(value_type::make_string(str))
+      {}
+
+      /**
+       *  @brief
+       *  Concatenation constructor.
+       *
+       *  @details
+       *  Powers dart::operator + for the purposes of string concatenation.
+       */
+      template <class Str = String, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_string_t, Str, shim::string_view, shim::string_view>::value
+        >
+      >
+      basic_string(shim::string_view base, shim::string_view app) :
+        val(value_type::make_string(base, app))
+      {}
+
       /**
        *  @brief
        *  Constructor allows an existing packet instance to be wrapped
@@ -3511,6 +3563,23 @@ namespace dart {
       >
       basic_string& operator =(shim::string_view str) &;
 
+      /**
+       *  @brief
+       *  "In place" concatenation operator.
+       *
+       *  @details
+       *  Operator unfortunately does not actually work in place due to the fact
+       *  that Dart strings are always precisely sized, not leaving room for
+       *  additional characters like std::string.
+       *  Concats the given suffix into a new string and assigns to itself
+       */
+      template <class Str = String, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_string_t, Str, shim::string_view, shim::string_view>::value
+        >
+      >
+      basic_string& operator +=(shim::string_view str);
+
       /**
        *  @brief
        *  Dereference operator.
@@ -3564,7 +3633,7 @@ namespace dart {
        *  @brief
        *  String conversion operator.
        */
-      explicit operator shim::string_view() const noexcept;
+      operator shim::string_view() const noexcept;
 
       /**
        *  @brief
@@ -3835,7 +3904,7 @@ namespace dart {
           std::is_integral<Arg>::value
         >* = nullptr
       >
-      explicit basic_number(Arg val) :
+      basic_number(Arg val) :
         val(value_type::make_integer(val))
       {}
 
@@ -3851,7 +3920,7 @@ namespace dart {
           std::is_floating_point<Arg>::value
         >* = nullptr
       >
-      explicit basic_number(Arg val) :
+      basic_number(Arg val) :
         val(value_type::make_decimal(val))
       {}
 
@@ -4030,6 +4099,62 @@ namespace dart {
       >
       basic_number& operator =(Num val) &;
 
+      template <class Arg, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Number, Arg>::value
+        >
+      >
+      basic_number& operator +=(Arg val) noexcept;
+
+      template <class Arg, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Number, Arg>::value
+        >
+      >
+      basic_number& operator -=(Arg val) noexcept;
+
+      template <class Arg, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Number, Arg>::value
+        >
+      >
+      basic_number& operator *=(Arg val) noexcept;
+
+      template <class Arg, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Number, Arg>::value
+        >
+      >
+      basic_number& operator /=(Arg val) noexcept;
+
+      template <class Num = Number, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Num, double>::value
+        >
+      >
+      basic_number& operator ++() noexcept;
+
+      template <class Num = Number, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Num, double>::value
+        >
+      >
+      basic_number& operator --() noexcept;
+
+      template <class Num = Number, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Num, double>::value
+        >
+      >
+      basic_number operator ++(int) noexcept;
+
+      template <class Num = Number, class EnableIf =
+        std::enable_if_t<
+          meta::is_detected<make_decimal_t, Num, double>::value
+        >
+      >
+      basic_number operator --(int) noexcept;
+
       /**
        *  @brief
        *  Dereference operator.
@@ -4076,14 +4201,19 @@ namespace dart {
       /**
        *  @brief
        *  Machine type conversion operator.
+       *
+       *  @details
+       *  Operator logically exists to allow conversion into integral types,
+       *  but is written in terms of operator T() to avoid overload ambiguity issues
        */
-      explicit operator int64_t() const noexcept;
-
-      /**
-       *  @brief
-       *  Machine type conversion operator.
-       */
-      explicit operator double() const noexcept;
+      template <class T,
+        std::enable_if_t<
+          std::is_integral<T>::value
+          ||
+          std::is_floating_point<T>::value
+        >* = nullptr
+      >
+      operator T() const noexcept;
 
       /**
        *  @brief
@@ -5649,7 +5779,7 @@ namespace dart {
           enabled
         >
       >
-      static basic_heap make_string(shim::string_view val);
+      static basic_heap make_string(shim::string_view base, shim::string_view app = "");
 
       /**
        *  @brief
@@ -7689,7 +7819,7 @@ namespace dart {
       basic_heap(detail::array_tag) :
         data(make_shareable<RefCount<packet_elements>>())
       {}
-      basic_heap(detail::string_tag, shim::string_view val);
+      basic_heap(detail::string_tag, shim::string_view base, shim::string_view);
       basic_heap(detail::integer_tag, int64_t val) noexcept : data(val) {}
       basic_heap(detail::decimal_tag, double val) noexcept : data(val) {}
       basic_heap(detail::boolean_tag, bool val) noexcept : data(val) {}
@@ -10866,7 +10996,7 @@ namespace dart {
           enabled
         >
       >
-      static basic_packet make_string(shim::string_view val);
+      static basic_packet make_string(shim::string_view base, shim::string_view app = "");
 
       /**
        *  @brief
diff --git a/include/dart/api.tcc b/include/dart/api.tcc
index a64188e..3c5248f 100644
--- a/include/dart/api.tcc
+++ b/include/dart/api.tcc
@@ -431,14 +431,16 @@ namespace dart {
   }
 
   template <class Number>
-  basic_number<Number>::operator int64_t() const noexcept {
-    if (is_integer()) return integer();
-    else return static_cast<int64_t>(decimal());
-  }
-
-  template <class Number>
-  basic_number<Number>::operator double() const noexcept {
-    return numeric();
+  template <class T,
+    std::enable_if_t<
+      std::is_integral<T>::value
+      ||
+      std::is_floating_point<T>::value
+    >*
+  >
+  basic_number<Number>::operator T() const noexcept {
+    if (is_integer()) return static_cast<T>(integer());
+    else return static_cast<T>(decimal());
   }
 
   template <class Object>
diff --git a/include/dart/common.h b/include/dart/common.h
index 1216e76..351e1c6 100644
--- a/include/dart/common.h
+++ b/include/dart/common.h
@@ -1228,10 +1228,11 @@ namespace dart {
     }
 
     template <template <class> class RefCount>
-    raw_type identify_string(shim::string_view val) noexcept {
-      if (val.size() > std::numeric_limits<uint16_t>::max()) {
+    raw_type identify_string(shim::string_view base, shim::string_view app = "") noexcept {
+      auto total = base.size() + app.size();
+      if (total > std::numeric_limits<uint16_t>::max()) {
         return detail::raw_type::big_string;
-      } else if (val.size() > sso_bytes<RefCount>()) {
+      } else if (total > sso_bytes<RefCount>()) {
         return detail::raw_type::string;
       } else {
         return detail::raw_type::small_string;
diff --git a/include/dart/conversion_traits.h b/include/dart/conversion_traits.h
index 35acd5e..8a4c55a 100644
--- a/include/dart/conversion_traits.h
+++ b/include/dart/conversion_traits.h
@@ -1080,14 +1080,18 @@ namespace dart {
       struct compare_impl<integer_tag> {
         template <class Packet>
         static bool compare(Packet const& pkt, int64_t val) noexcept {
-          return pkt.is_integer() && pkt.integer() == val;
+          if (pkt.is_integer()) return pkt.integer() == val;
+          else if (pkt.is_decimal()) return pkt.decimal() == val;
+          else return false;
         }
       };
       template <>
       struct compare_impl<decimal_tag> {
         template <class Packet>
         static bool compare(Packet const& pkt, double val) noexcept {
-          return pkt.is_decimal() && pkt.decimal() == val;
+          if (pkt.is_integer()) return pkt.integer() == val;
+          else if (pkt.is_decimal()) return pkt.decimal() == val;
+          else return false;
         }
       };
       template <>
diff --git a/include/dart/heap/string.tcc b/include/dart/heap/string.tcc
index 69ee3e2..163af38 100644
--- a/include/dart/heap/string.tcc
+++ b/include/dart/heap/string.tcc
@@ -11,8 +11,8 @@ namespace dart {
 
   template <template <class> class RefCount>
   template <bool enabled, class EnableIf>
-  basic_heap<RefCount> basic_heap<RefCount>::make_string(shim::string_view val) {
-    return basic_heap(detail::string_tag {}, val);
+  basic_heap<RefCount> basic_heap<RefCount>::make_string(shim::string_view base, shim::string_view app) {
+    return basic_heap(detail::string_tag {}, base, app);
   }
 
   template <template <class> class RefCount>
@@ -43,23 +43,25 @@ namespace dart {
   }
 
   template <template <class> class RefCount>
-  basic_heap<RefCount>::basic_heap(detail::string_tag, shim::string_view val) {
-    auto type = detail::identify_string<RefCount>(val);
+  basic_heap<RefCount>::basic_heap(detail::string_tag, shim::string_view base, shim::string_view app) {
+    auto len = base.size() + app.size();
+    auto type = detail::identify_string<RefCount>(base, app);
     switch (type) {
       case detail::raw_type::string:
       case detail::raw_type::big_string:
         {
           // String is too large for SSO.
           // Allocate some space and copy the string data in.
-          auto ptr = std::make_unique<char[]>(val.size() + 1);
-          std::copy(val.begin(), val.end(), ptr.get());
-          ptr[val.size()] = '\0';
+          auto ptr = std::make_unique<char[]>(len + 1);
+          std::copy(base.begin(), base.end(), ptr.get());
+          std::copy(app.begin(), app.end(), ptr.get() + base.size());
+          ptr[len] = '\0';
 
           // Move the data in.
           // FIXME: Turns out there's no portable way to use std::make_shared
           // to allocate an array of characters in C++14.
           auto shared = std::shared_ptr<char> {ptr.release(), +[] (char* ptr) { delete[] ptr; }};
-          data = detail::dynamic_string_layout {std::move(shared), val.size()};
+          data = detail::dynamic_string_layout {std::move(shared), len};
           break;
         }
       default:
@@ -68,15 +70,16 @@ namespace dart {
 
           // String is small enough for SSO, copy the string contents into the in-situ buffer.
           detail::inline_string_layout layout;
-          std::copy(val.begin(), val.end(), layout.buffer.begin());
+          std::copy(base.begin(), base.end(), layout.buffer.begin());
+          std::copy(app.begin(), app.end(), layout.buffer.begin() + base.size());
 
           // Terminate the string and set the number of remaining bytes.
           // These two operations may touch the same byte.
           // XXX: Have to access through std::array::data member as writing the null terminator
           // is intentionally allowed to access 1 byte out of range if the string is the max
           // SSO length, and MSVC asserts on out of bounds accesses in std::array.
-          layout.buffer.data()[val.size()] = '\0';
-          layout.left = static_cast<uint8_t>(sso_bytes) - static_cast<uint8_t>(val.size());
+          layout.buffer.data()[len] = '\0';
+          layout.left = static_cast<uint8_t>(sso_bytes) - static_cast<uint8_t>(len);
           data = layout;
         }
     }
diff --git a/include/dart/operators.tcc b/include/dart/operators.tcc
index df93416..6637580 100644
--- a/include/dart/operators.tcc
+++ b/include/dart/operators.tcc
@@ -41,6 +41,60 @@ namespace dart {
     return !(lhs == rhs);
   }
 
+  template <class String, class Str, class =
+    std::enable_if_t<
+      std::is_convertible<
+        std::decay_t<Str>,
+        shim::string_view
+      >::value
+    >
+  >
+  basic_string<String> operator +(basic_string<String> const& lhs, Str const& rhs) {
+    shim::string_view str = rhs;
+    return basic_string<String> {lhs, str};
+  }
+
+  template <class String, class Str, class =
+    std::enable_if_t<
+      std::is_convertible<
+        std::decay_t<Str>,
+        shim::string_view
+      >::value
+    >
+  >
+  basic_string<String> operator +(Str const& lhs, basic_string<String> const& rhs) {
+    shim::string_view str = rhs;
+    return basic_string<String> {lhs, str};
+  }
+
+#define DART_DEFINE_ARITHMETIC_OPERATORS(op)                                              \
+  template <class Number, class T, class =                                                \
+    std::enable_if_t<                                                                     \
+      std::is_integral<T>::value                                                          \
+      ||                                                                                  \
+      std::is_floating_point<T>::value                                                    \
+    >                                                                                     \
+  >                                                                                       \
+  double operator op(basic_number<Number> const& lhs, T rhs) noexcept {                   \
+    return lhs.numeric() op rhs;                                                          \
+  }                                                                                       \
+  template <class Number, class T, class =                                                \
+    std::enable_if_t<                                                                     \
+      std::is_integral<T>::value                                                          \
+      ||                                                                                  \
+      std::is_floating_point<T>::value                                                    \
+    >                                                                                     \
+  >                                                                                       \
+  double operator op(T lhs, basic_number<Number> const& rhs) noexcept {                   \
+    return rhs op lhs;                                                                    \
+  }
+
+  DART_DEFINE_ARITHMETIC_OPERATORS(+);
+  DART_DEFINE_ARITHMETIC_OPERATORS(-);
+  DART_DEFINE_ARITHMETIC_OPERATORS(*);
+  DART_DEFINE_ARITHMETIC_OPERATORS(/);
+#undef DART_DEFINE_ARITHMETIC_OPERATORS
+
 #if DART_HAS_RAPIDJSON
   template <class Packet, class =
     std::enable_if_t<
diff --git a/include/dart/packet/string.tcc b/include/dart/packet/string.tcc
index 5d2c78c..fdfb503 100644
--- a/include/dart/packet/string.tcc
+++ b/include/dart/packet/string.tcc
@@ -11,8 +11,8 @@ namespace dart {
 
   template <template <class> class RefCount>
   template <bool enabled, class EnableIf>
-  basic_packet<RefCount> basic_packet<RefCount>::make_string(shim::string_view val) {
-    return basic_heap<RefCount>::make_string(val);
+  basic_packet<RefCount> basic_packet<RefCount>::make_string(shim::string_view base, shim::string_view app) {
+    return basic_heap<RefCount>::make_string(base, app);
   }
 
   template <template <class> class RefCount>
diff --git a/include/dart/primitive.tcc b/include/dart/primitive.tcc
index 4c63434..484ef7d 100644
--- a/include/dart/primitive.tcc
+++ b/include/dart/primitive.tcc
@@ -27,6 +27,64 @@ namespace dart {
     this->val = std::forward<Bool>(val);
   }
 
+  template <class Number>
+  template <class Arg, class EnableIf>
+  basic_number<Number>& basic_number<Number>::operator +=(Arg val) noexcept {
+    this->val = numeric() + val;
+    return *this;
+  }
+
+  template <class Number>
+  template <class Arg, class EnableIf>
+  basic_number<Number>& basic_number<Number>::operator -=(Arg val) noexcept {
+    this->val = numeric() - val;
+    return *this;
+  }
+
+  template <class Number>
+  template <class Arg, class EnableIf>
+  basic_number<Number>& basic_number<Number>::operator *=(Arg val) noexcept {
+    this->val = numeric() * val;
+    return *this;
+  }
+
+  template <class Number>
+  template <class Arg, class EnableIf>
+  basic_number<Number>& basic_number<Number>::operator /=(Arg val) noexcept {
+    this->val = numeric() / val;
+    return *this;
+  }
+
+  template <class Number>
+  template <class Num, class EnableIf>
+  basic_number<Number>& basic_number<Number>::operator ++() noexcept {
+    val = numeric() + 1;
+    return *this;
+  }
+
+  template <class Number>
+  template <class Num, class EnableIf>
+  basic_number<Number>& basic_number<Number>::operator --() noexcept {
+    val = numeric() - 1;
+    return *this;
+  }
+
+  template <class Number>
+  template <class Num, class EnableIf>
+  basic_number<Number> basic_number<Number>::operator ++(int) noexcept {
+    auto copy = *this;
+    val = numeric() + 1;
+    return copy;
+  }
+
+  template <class Number>
+  template <class Num, class EnableIf>
+  basic_number<Number> basic_number<Number>::operator --(int) noexcept {
+    auto copy = *this;
+    val = numeric() - 1;
+    return copy;
+  }
+
   template <class Number>
   int64_t basic_number<Number>::integer() const {
     return val.integer();
diff --git a/include/dart/string.tcc b/include/dart/string.tcc
index afb9df8..3c9b798 100644
--- a/include/dart/string.tcc
+++ b/include/dart/string.tcc
@@ -16,6 +16,14 @@ namespace dart {
     this->val = std::forward<Str>(val);
   }
 
+  template <class String>
+  template <class Str, class EnableIf>
+  basic_string<String>& basic_string<String>::operator +=(shim::string_view str) {
+    // Concat and re-assign
+    val = String::make_string(strv(),  str);
+    return *this;
+  }
+
   template <class String>
   char const* basic_string<String>::str() const noexcept {
     return val.str();
diff --git a/test/operator_unit_tests.cc b/test/operator_unit_tests.cc
index 5a9c894..ad73b10 100644
--- a/test/operator_unit_tests.cc
+++ b/test/operator_unit_tests.cc
@@ -1461,6 +1461,30 @@ SCENARIO("mutable dart types can be assigned to from many types", "[operator uni
           static_assert(noexcept(val == str), "Dart is misconfigured");
           static_assert(dart::convert::are_nothrow_comparable<char const*, string>::value, "Dart is misconfigured");
         }
+
+        DYNAMIC_WHEN("the value is concatenated with a string literal", idx) {
+          auto lhs = val + " hello";
+          auto rhs = "hello " + val;
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(lhs == "hello world hello");
+            REQUIRE("hello world hello" == lhs);
+            REQUIRE(rhs == "hello hello world");
+            REQUIRE("hello hello world" == rhs);
+          }
+        }
+
+        DYNAMIC_WHEN("the value is concatenated with a string literal in place", idx) {
+          string second = "hello ";
+          second += val;
+          val += " hello";
+
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(second == "hello hello world");
+            REQUIRE("hello hello world" == second);
+            REQUIRE(val == "hello world hello");
+            REQUIRE("hello world hello" == val);
+          }
+        }
       }
 
       DYNAMIC_WHEN("the value is assigned from a std::string", idx) {
@@ -1478,6 +1502,33 @@ SCENARIO("mutable dart types can be assigned to from many types", "[operator uni
           static_assert(noexcept(val == str), "Dart is misconfigured");
           static_assert(dart::convert::are_nothrow_comparable<std::string, string>::value, "Dart is misconfigured");
         }
+
+        DYNAMIC_WHEN("the value is concatenated with a std::string", idx) {
+          std::string lhsstr = " hello";
+          std::string rhsstr = "hello ";
+
+          auto lhs = val + lhsstr;
+          auto rhs = rhsstr + val;
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(lhs == "hello world hello");
+            REQUIRE("hello world hello" == lhs);
+            REQUIRE(rhs == "hello hello world");
+            REQUIRE("hello hello world" == rhs);
+          }
+        }
+
+        DYNAMIC_WHEN("the value is concatenated with a std::string in place", idx) {
+          std::string base = "hello ", app = " hello";
+          string second {base};
+          second += val;
+          val += app;
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(second == "hello hello world");
+            REQUIRE("hello hello world" == second);
+            REQUIRE(val == "hello world hello");
+            REQUIRE("hello world hello" == val);
+          }
+        }
       }
 
       DYNAMIC_WHEN("the value is assigned from a std::string_view", idx) {
@@ -1495,6 +1546,33 @@ SCENARIO("mutable dart types can be assigned to from many types", "[operator uni
           static_assert(noexcept(val == str), "Dart is misconfigured");
           static_assert(dart::convert::are_nothrow_comparable<dart::shim::string_view, string>::value, "Dart is misconfigured");
         }
+
+        DYNAMIC_WHEN("the value is concatenated with a std::string_view", idx) {
+          dart::shim::string_view lhsstr = " hello";
+          dart::shim::string_view rhsstr = "hello ";
+
+          auto lhs = val + lhsstr;
+          auto rhs = rhsstr + val;
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(lhs == "hello world hello");
+            REQUIRE("hello world hello" == lhs);
+            REQUIRE(rhs == "hello hello world");
+            REQUIRE("hello hello world" == rhs);
+          }
+        }
+
+        DYNAMIC_WHEN("the value is concatenated with a std::string_view in place", idx) {
+          dart::shim::string_view base = "hello ", app = " hello";
+          string second {base};
+          second += val;
+          val += app;
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(second == "hello hello world");
+            REQUIRE("hello hello world" == second);
+            REQUIRE(val == "hello world hello");
+            REQUIRE("hello world hello" == val);
+          }
+        }
       }
     });
   }
@@ -1531,6 +1609,48 @@ SCENARIO("mutable dart types can be assigned to from many types", "[operator uni
           static_assert(noexcept(1337 == val), "Dart is misconfigured");
           static_assert(dart::convert::are_nothrow_comparable<int, number>::value, "Dart is misconfigured");
         }
+
+        DYNAMIC_WHEN("arithmetic is performed with the value", idx) {
+          auto first = val + 1337;
+          auto second = val - 1337;
+          auto third = val * 2;
+          auto fourth = val / 2;
+
+          auto firstcpy = val;
+          firstcpy += 1337;
+          auto secondcpy = val;
+          secondcpy -= 1337;
+          auto thirdcpy = val;
+          thirdcpy *= 2;
+          auto fourthcpy = val;
+          fourthcpy /= 2;
+          auto fifthcpy = val;
+          auto fifth = fifthcpy++;
+          auto sixthcpy = val;
+          auto sixth = sixthcpy--;
+          auto seventhcpy = val;
+          auto seventh = ++seventhcpy;
+          auto eighthcpy = val;
+          auto eighth = --eighthcpy;
+          DYNAMIC_THEN("it takes on the value we expect", idx) {
+            REQUIRE(first == firstcpy);
+            REQUIRE(firstcpy == first);
+            REQUIRE(second == secondcpy);
+            REQUIRE(secondcpy == second);
+            REQUIRE(third == thirdcpy);
+            REQUIRE(thirdcpy == third);
+            REQUIRE(fourth == fourthcpy);
+            REQUIRE(fourthcpy == fourth);
+            REQUIRE(fifthcpy == fifth + 1);
+            REQUIRE(fifth + 1 == fifthcpy);
+            REQUIRE(sixthcpy == sixth - 1);
+            REQUIRE(sixth - 1 == sixthcpy);
+            REQUIRE(seventhcpy == seventh);
+            REQUIRE(seventh == seventhcpy);
+            REQUIRE(eighthcpy == eighth);
+            REQUIRE(eighth == eighthcpy);
+          }
+        }
       }
 
       DYNAMIC_WHEN("the value is assigned from a decimal literal", idx) {