feat(SAMPLE-027): add TimeSpan compound assignment operators

XNA 4.0's FuzzyLogic sample does `timeChasingThisMouse += gameTime.ElapsedGameTime;`
in Tank.ChooseBehavior. C# synthesizes compound assignment from `operator +`, so
.NET's TimeSpan does not declare `+=`/`-=` and neither did this port; C++ has no
such synthesis, so the operators have to exist for the expression to compile.

Both forward to Add/Subtract, which is what the value-returning `operator+`/`-`
already do, so they inherit the same OverflowException behaviour rather than
duplicating the range checks. This follows the existing Decimal::operator+=
precedent for a compound assignment C# generates rather than declares.

Six tests cover the in-place value, that the returned reference is the same
object, that the result equals the value-returning operator it is built on, and
the overflow path at both ends.

Author: robertvokac

modules/core/include/System/TimeSpan.hpp

@@ -577,6 +577,29 @@ namespace System {
         /** Adds @p t2 to this TimeSpan. */
         TimeSpan operator+(const TimeSpan &t2) const;
 
+    public:
+        /**
+         * @brief Adds @p t2 to this TimeSpan in place.
+         *
+         * C++ counterpart of the compound assignment C# synthesizes from
+         * <c>operator +(TimeSpan, TimeSpan)</c>.
+         *
+         * @param t2 The interval to add.
+         * @return A reference to this TimeSpan after the addition.
+         */
+        TimeSpan &operator+=(const TimeSpan &t2);
+
+        /**
+         * @brief Subtracts @p t2 from this TimeSpan in place.
+         *
+         * C++ counterpart of the compound assignment C# synthesizes from
+         * <c>operator -(TimeSpan, TimeSpan)</c>.
+         *
+         * @param t2 The interval to subtract.
+         * @return A reference to this TimeSpan after the subtraction.
+         */
+        TimeSpan &operator-=(const TimeSpan &t2);
+
     public:
         /** Multiplies this TimeSpan by scalar @p factor. */
         TimeSpan operator*(double factor) const;

modules/core/src/System/TimeSpan.cpp

@@ -609,6 +609,18 @@ namespace System {
 
     TimeSpan TimeSpan::operator+(const TimeSpan &t2) const { return Add(t2); }
 
+    TimeSpan &TimeSpan::operator+=(const TimeSpan &t2)
+    {
+        *this = Add(t2);
+        return *this;
+    }
+
+    TimeSpan &TimeSpan::operator-=(const TimeSpan &t2)
+    {
+        *this = Subtract(t2);
+        return *this;
+    }
+
 
     TimeSpan TimeSpan::operator*(double factor) const {
         if (std::isnan(factor)) {

modules/core/tests/System/TimeSpanTests.cpp

@@ -838,3 +838,44 @@ TEST(TimeSpanParseExact1943Tests, TheEscapeEdgeCasesAreRejectedAsDotNetRejectsTh
     EXPECT_FALSE(TimeSpan::TryParseExact("1", "hh\\", unused));    // trailing '\' is an error
     EXPECT_FALSE(TimeSpan::TryParseExact("01:30", "hh':'mm'", unused));  // unterminated quote
 }
+
+TEST(TimeSpanTests, OperatorPlusAssign_AccumulatesInPlace) {
+    TimeSpan total = TimeSpan::Zero;
+    total += TimeSpan::FromSeconds(1.5);
+    EXPECT_EQ(total.getTicksProperty(), 15000000LL);
+    total += TimeSpan::FromSeconds(2.5);
+    EXPECT_DOUBLE_EQ(total.getTotalSecondsProperty(), 4.0);
+    // The result must equal the value-returning operator+ it is built on.
+    EXPECT_EQ(total, TimeSpan::FromSeconds(1.5) + TimeSpan::FromSeconds(2.5));
+}
+
+TEST(TimeSpanTests, OperatorPlusAssign_ReturnsReferenceToTheSameObject) {
+    TimeSpan value = TimeSpan::FromSeconds(1.0);
+    TimeSpan& returned = (value += TimeSpan::FromSeconds(1.0));
+    EXPECT_EQ(&returned, &value);
+    EXPECT_DOUBLE_EQ(value.getTotalSecondsProperty(), 2.0);
+}
+
+TEST(TimeSpanTests, OperatorPlusAssign_OverflowsThroughAdd) {
+    TimeSpan value = TimeSpan::MaxValue;
+    EXPECT_THROW(value += TimeSpan(static_cast<longcs>(1)), System::OverflowException);
+}
+
+TEST(TimeSpanTests, OperatorMinusAssign_SubtractsInPlace) {
+    TimeSpan value = TimeSpan(5, 0, 0);
+    value -= TimeSpan(2, 30, 0);
+    EXPECT_EQ(value.getTicksProperty(), 90000000000LL);
+    EXPECT_EQ(value, TimeSpan(5, 0, 0) - TimeSpan(2, 30, 0));
+}
+
+TEST(TimeSpanTests, OperatorMinusAssign_ReturnsReferenceToTheSameObject) {
+    TimeSpan value = TimeSpan::FromSeconds(3.0);
+    TimeSpan& returned = (value -= TimeSpan::FromSeconds(1.0));
+    EXPECT_EQ(&returned, &value);
+    EXPECT_DOUBLE_EQ(value.getTotalSecondsProperty(), 2.0);
+}
+
+TEST(TimeSpanTests, OperatorMinusAssign_OverflowsThroughSubtract) {
+    TimeSpan value = TimeSpan::MinValue;
+    EXPECT_THROW(value -= TimeSpan(static_cast<longcs>(1)), System::OverflowException);
+}