deps: update V8 to 6.3.292.46

PR-URL: https://github.com/nodejs/node/pull/16271
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Myles Borins <myles.borins@gmail.com>

2 files changed, 172 insertions, 0 deletions

diff --git a/deps/v8/test/unittests/base/logging-unittest.cc b/deps/v8/test/unittests/base/logging-unittest.cc
index 35da8a33db..fd334ec49d 100644
--- a/deps/v8/test/unittests/base/logging-unittest.cc
+++ b/deps/v8/test/unittests/base/logging-unittest.cc
@@ -10,6 +10,7 @@
 
 namespace v8 {
 namespace base {
+namespace logging_unittest {
 
 namespace {
 
@@ -67,6 +68,23 @@ TEST(LoggingTest, CompareAgainstStaticConstPointer) {
   CHECK_##name(lhs, rhs);          \
   DCHECK_##name(lhs, rhs)
 
+namespace {
+std::string FailureMessage(const char* msg, const char* debug_msg) {
+  std::string regexp(msg);
+#ifdef DEBUG
+  regexp.append(" (").append(debug_msg).append(")");
+#endif
+  size_t last_pos = 0;
+  do {
+    size_t pos = regexp.find_first_of("(){}+*", last_pos);
+    if (pos == std::string::npos) break;
+    regexp.insert(pos, "\\");
+    last_pos = pos + 2;
+  } while (true);
+  return regexp;
+}
+}  // namespace
+
 TEST(LoggingTest, CompareWithDifferentSignedness) {
   int32_t i32 = 10;
   uint32_t u32 = 20;
@@ -80,6 +98,11 @@ TEST(LoggingTest, CompareWithDifferentSignedness) {
   CHECK_BOTH(IMPLIES, i32, i64);
   CHECK_BOTH(IMPLIES, u32, i64);
   CHECK_BOTH(IMPLIES, !u32, !i64);
+
+  // Check that the values are output correctly on error.
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_GT(i32, u64); })(),
+      FailureMessage("Check failed: i32 > u64", "10 vs. 40"));
 }
 
 TEST(LoggingTest, CompareWithReferenceType) {
@@ -93,7 +116,134 @@ TEST(LoggingTest, CompareWithReferenceType) {
   CHECK_BOTH(LT, *&i32, u64);
   CHECK_BOTH(IMPLIES, *&i32, i64);
   CHECK_BOTH(IMPLIES, *&i32, u64);
+
+  // Check that the values are output correctly on error.
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_GT(*&i32, u64); })(),
+      FailureMessage("Check failed: *&i32 > u64", "10 vs. 40"));
+}
+
+enum TestEnum1 { ONE, TWO };
+enum TestEnum2 : uint16_t { FOO = 14, BAR = 5 };
+enum class TestEnum3 { A, B };
+enum class TestEnum4 : uint8_t { FIRST, SECOND };
+
+TEST(LoggingTest, CompareEnumTypes) {
+  // All these checks should compile (!) and succeed.
+  CHECK_BOTH(EQ, ONE, ONE);
+  CHECK_BOTH(LT, ONE, TWO);
+  CHECK_BOTH(EQ, BAR, 5);
+  CHECK_BOTH(LT, BAR, FOO);
+  CHECK_BOTH(EQ, TestEnum3::A, TestEnum3::A);
+  CHECK_BOTH(LT, TestEnum3::A, TestEnum3::B);
+  CHECK_BOTH(EQ, TestEnum4::FIRST, TestEnum4::FIRST);
+  CHECK_BOTH(LT, TestEnum4::FIRST, TestEnum4::SECOND);
+}
+
+class TestClass1 {
+ public:
+  bool operator==(const TestClass1&) const { return true; }
+  bool operator!=(const TestClass1&) const { return false; }
+};
+class TestClass2 {
+ public:
+  explicit TestClass2(int val) : val_(val) {}
+  bool operator<(const TestClass2& other) const { return val_ < other.val_; }
+  int val() const { return val_; }
+
+ private:
+  int val_;
+};
+std::ostream& operator<<(std::ostream& str, const TestClass2& val) {
+  return str << "TestClass2(" << val.val() << ")";
+}
+
+TEST(LoggingTest, CompareClassTypes) {
+  // All these checks should compile (!) and succeed.
+  CHECK_BOTH(EQ, TestClass1{}, TestClass1{});
+  CHECK_BOTH(LT, TestClass2{2}, TestClass2{7});
+
+  // Check that the values are output correctly on error.
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_NE(TestClass1{}, TestClass1{}); })(),
+      FailureMessage("Check failed: TestClass1{} != TestClass1{}",
+                     "<unprintable> vs. <unprintable>"));
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_LT(TestClass2{4}, TestClass2{3}); })(),
+      FailureMessage("Check failed: TestClass2{4} < TestClass2{3}",
+                     "TestClass2(4) vs. TestClass2(3)"));
+}
+
+TEST(LoggingDeathTest, OutputEnumValues) {
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_EQ(ONE, TWO); })(),
+      FailureMessage("Check failed: ONE == TWO", "0 vs. 1"));
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_NE(BAR, 2 + 3); })(),
+      FailureMessage("Check failed: BAR != 2 + 3", "5 vs. 5"));
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_EQ(TestEnum3::A, TestEnum3::B); })(),
+      FailureMessage("Check failed: TestEnum3::A == TestEnum3::B", "0 vs. 1"));
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_GE(TestEnum4::FIRST, TestEnum4::SECOND); })(),
+      FailureMessage("Check failed: TestEnum4::FIRST >= TestEnum4::SECOND",
+                     "0 vs. 1"));
+}
+
+enum TestEnum5 { TEST_A, TEST_B };
+enum class TestEnum6 { TEST_C, TEST_D };
+std::ostream& operator<<(std::ostream& str, TestEnum5 val) {
+  return str << (val == TEST_A ? "A" : "B");
+}
+void operator<<(std::ostream& str, TestEnum6 val) {
+  str << (val == TestEnum6::TEST_C ? "C" : "D");
+}
+
+TEST(LoggingDeathTest, OutputEnumWithOutputOperator) {
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_EQ(TEST_A, TEST_B); })(),
+      FailureMessage("Check failed: TEST_A == TEST_B", "A vs. B"));
+  ASSERT_DEATH_IF_SUPPORTED(
+      ([&] { CHECK_GE(TestEnum6::TEST_C, TestEnum6::TEST_D); })(),
+      FailureMessage("Check failed: TestEnum6::TEST_C >= TestEnum6::TEST_D",
+                     "C vs. D"));
+}
+
+TEST(LoggingDeathTest, FatalKills) {
+  ASSERT_DEATH_IF_SUPPORTED(FATAL("Dread pirate"), "Dread pirate");
+}
+
+TEST(LoggingDeathTest, DcheckIsOnlyFatalInDebug) {
+#ifdef DEBUG
+  ASSERT_DEATH_IF_SUPPORTED(DCHECK(false && "Dread pirate"), "Dread pirate");
+#else
+  // DCHECK should be non-fatal if DEBUG is undefined.
+  DCHECK(false && "I'm a benign teapot");
+#endif
+}
+
+namespace {
+void DcheckOverrideFunction(const char*, int, const char*) {}
+}  // namespace
+
+TEST(LoggingDeathTest, V8_DcheckCanBeOverridden) {
+  // Default DCHECK state should be fatal.
+  ASSERT_DEATH_IF_SUPPORTED(V8_Dcheck(__FILE__, __LINE__, "Dread pirate"),
+                            "Dread pirate");
+
+  ASSERT_DEATH_IF_SUPPORTED(
+      {
+        v8::base::SetDcheckFunction(&DcheckOverrideFunction);
+        // This should be non-fatal.
+        V8_Dcheck(__FILE__, __LINE__, "I'm a benign teapot.");
+
+        // Restore default behavior, and assert on lethality.
+        v8::base::SetDcheckFunction(nullptr);
+        V8_Dcheck(__FILE__, __LINE__, "Dread pirate");
+      },
+      "Dread pirate");
 }
 
+}  // namespace logging_unittest
 }  // namespace base
 }  // namespace v8
diff --git a/deps/v8/test/unittests/base/template-utils-unittest.cc b/deps/v8/test/unittests/base/template-utils-unittest.cc
index 1f434faee8..ea8796a123 100644
--- a/deps/v8/test/unittests/base/template-utils-unittest.cc
+++ b/deps/v8/test/unittests/base/template-utils-unittest.cc
@@ -8,6 +8,7 @@
 
 namespace v8 {
 namespace base {
+namespace template_utils_unittest {
 
 ////////////////////////////
 // Test make_array.
@@ -80,5 +81,26 @@ TEST_PASS_VALUE_OR_REF0(false, const std::string&, const std::string&);
 TEST_PASS_VALUE_OR_REF0(false, int, const int);
 TEST_PASS_VALUE_OR_REF0(false, int, const int&);
 
+//////////////////////////////
+// Test has_output_operator.
+//////////////////////////////
+
+// Intrinsic types:
+static_assert(has_output_operator<int>::value, "int can be output");
+static_assert(has_output_operator<void*>::value, "void* can be output");
+static_assert(has_output_operator<uint64_t>::value, "int can be output");
+
+// Classes:
+class TestClass1 {};
+class TestClass2 {};
+extern std::ostream& operator<<(std::ostream& str, TestClass2&);
+static_assert(!has_output_operator<TestClass1>::value,
+              "TestClass1 can not be output");
+static_assert(has_output_operator<TestClass2>::value,
+              "non-const TestClass2 can be output");
+static_assert(!has_output_operator<const TestClass2>::value,
+              "const TestClass2 can not be output");
+
+}  // namespace template_utils_unittest
 }  // namespace base
 }  // namespace v8