1 files changed, 170 insertions, 0 deletions
diff --git a/mfbt/tests/gtest/TestMozDbg.cpp b/mfbt/tests/gtest/TestMozDbg.cpp
new file mode 100644
index 0000000000..24ccd8ed37
--- /dev/null
+++ b/mfbt/tests/gtest/TestMozDbg.cpp
@@ -0,0 +1,170 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <iostream>
+#include <type_traits>
+
+#include "gtest/gtest.h"
+#include "mozilla/DbgMacro.h"
+#include "mozilla/Unused.h"
+
+using namespace mozilla;
+
+#define TEST_MOZ_DBG_TYPE_IS(type_, expression_...)                    \
+  static_assert(std::is_same_v<type_, decltype(MOZ_DBG(expression_))>, \
+                "MOZ_DBG should return the indicated type")
+
+#define TEST_MOZ_DBG_TYPE_SAME(expression_...)                                 \
+  static_assert(                                                               \
+      std::is_same_v<decltype((expression_)), decltype(MOZ_DBG(expression_))>, \
+      "MOZ_DBG should return the same type")
+
+struct Number {
+  explicit Number(int aValue) : mValue(aValue) {}
+
+  Number(const Number& aOther) = default;
+
+  Number(Number&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
+
+  Number& operator=(const Number& aOther) = default;
+
+  Number& operator=(Number&& aOther) {
+    mValue = aOther.mValue;
+    aOther.mValue = 0;
+    return *this;
+  }
+
+  ~Number() { mValue = -999; }
+
+  int mValue;
+
+  MOZ_DEFINE_DBG(Number, mValue)
+};
+
+struct MoveOnly {
+  explicit MoveOnly(int aValue) : mValue(aValue) {}
+
+  MoveOnly(const MoveOnly& aOther) = delete;
+
+  MoveOnly(MoveOnly&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
+
+  MoveOnly& operator=(MoveOnly& aOther) = default;
+
+  MoveOnly& operator=(MoveOnly&& aOther) {
+    mValue = aOther.mValue;
+    aOther.mValue = 0;
+    return *this;
+  }
+
+  int mValue;
+
+  MOZ_DEFINE_DBG(MoveOnly)
+};
+
+void StaticAssertions() {
+  int x = 123;
+  Number y(123);
+  Number z(234);
+  MoveOnly w(456);
+
+  // Static assertions.
+
+  // lvalues
+  TEST_MOZ_DBG_TYPE_SAME(x);        // int&
+  TEST_MOZ_DBG_TYPE_SAME(y);        // Number&
+  TEST_MOZ_DBG_TYPE_SAME(x = 234);  // int&
+  TEST_MOZ_DBG_TYPE_SAME(y = z);    // Number&
+  TEST_MOZ_DBG_TYPE_SAME(w);        // MoveOnly&
+
+  // prvalues (which MOZ_DBG turns into xvalues by creating objects for them)
+  TEST_MOZ_DBG_TYPE_IS(int&&, 123);
+  TEST_MOZ_DBG_TYPE_IS(int&&, 1 + 2);
+  TEST_MOZ_DBG_TYPE_IS(int*&&, &x);
+  TEST_MOZ_DBG_TYPE_IS(int&&, x++);
+  TEST_MOZ_DBG_TYPE_IS(Number&&, Number(123));
+  TEST_MOZ_DBG_TYPE_IS(MoveOnly&&, MoveOnly(123));
+
+  // xvalues
+  TEST_MOZ_DBG_TYPE_SAME(std::move(y));  // int&&
+  TEST_MOZ_DBG_TYPE_SAME(std::move(y));  // Number&&
+  TEST_MOZ_DBG_TYPE_SAME(std::move(w));  // MoveOnly&
+
+  Unused << x;
+  Unused << y;
+  Unused << z;
+}
+
+TEST(MozDbg, ObjectValues)
+{
+  // Test that moves and assignments all operate correctly with MOZ_DBG wrapped
+  // around various parts of the expression.
+
+  Number a(1);
+  Number b(4);
+
+  ASSERT_EQ(a.mValue, 1);
+
+  MOZ_DBG(a.mValue);
+  ASSERT_EQ(a.mValue, 1);
+
+  MOZ_DBG(a.mValue + 1);
+  ASSERT_EQ(a.mValue, 1);
+
+  MOZ_DBG(a.mValue = 2);
+  ASSERT_EQ(a.mValue, 2);
+
+  MOZ_DBG(a).mValue = 3;
+  ASSERT_EQ(a.mValue, 3);
+
+  MOZ_DBG(a = b);
+  ASSERT_EQ(a.mValue, 4);
+  ASSERT_EQ(b.mValue, 4);
+
+  b.mValue = 5;
+  MOZ_DBG(a) = b;
+  ASSERT_EQ(a.mValue, 5);
+  ASSERT_EQ(b.mValue, 5);
+
+  b.mValue = 6;
+  MOZ_DBG(a = std::move(b));
+  ASSERT_EQ(a.mValue, 6);
+  ASSERT_EQ(b.mValue, 0);
+
+  b.mValue = 7;
+  MOZ_DBG(a) = std::move(b);
+  ASSERT_EQ(a.mValue, 7);
+  ASSERT_EQ(b.mValue, 0);
+
+  b.mValue = 8;
+  a = std::move(MOZ_DBG(b));
+  ASSERT_EQ(a.mValue, 8);
+  ASSERT_EQ(b.mValue, 0);
+
+  a = MOZ_DBG(Number(9));
+  ASSERT_EQ(a.mValue, 9);
+
+  MoveOnly c(1);
+  MoveOnly d(2);
+
+  c = std::move(MOZ_DBG(d));
+  ASSERT_EQ(c.mValue, 2);
+  ASSERT_EQ(d.mValue, 0);
+
+  c.mValue = 3;
+  d.mValue = 4;
+  c = MOZ_DBG(std::move(d));
+  ASSERT_EQ(c.mValue, 4);
+  ASSERT_EQ(d.mValue, 0);
+
+  c.mValue = 5;
+  d.mValue = 6;
+  MOZ_DBG(c = std::move(d));
+  ASSERT_EQ(c.mValue, 6);
+  ASSERT_EQ(d.mValue, 0);
+
+  c = MOZ_DBG(MoveOnly(7));
+  ASSERT_EQ(c.mValue, 7);
+}