Allow embedders to provide custom message delivery for an isolate.

runtime/vm/assert.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_ASSERT_H_
 #define VM_ASSERT_H_
 
 // TODO(5411406): include sstream for now, once we have a Utils::toString()
 // implemented for all the primitive types we can replace the usage of
 // sstream by Utils::toString()
@@ skipping 21 matching lines @@
 
   DynamicAssertionHelper(const char* file, int line, Kind kind)
       : file_(file), line_(line), kind_(kind) { }
 
   void Fail(const char* format, ...);
 
 #if defined(TESTING)
   template<typename E, typename A>
   void Equals(const E& expected, const A& actual);
 
+  template<typename E, typename A>
+  void NotEquals(const E& not_expected, const A& actual);
+
   template<typename E, typename A, typename T>
   void FloatEquals(const E& expected, const A& actual, const T& tol);
 
   template<typename E, typename A>
   void StringEquals(const E& expected, const A& actual);
 
   template<typename E, typename A>
   void LessThan(const E& left, const A& right);
 
   template<typename E, typename A>
@@ skipping 36 matching lines @@
 void DynamicAssertionHelper::Equals(const E& expected, const A& actual) {
   if (actual == expected) return;
   std::stringstream ess, ass;
   ess << expected;
   ass << actual;
   std::string es = ess.str(), as = ass.str();
   Fail("expected: <%s> but was: <%s>", es.c_str(), as.c_str());
 }
 
 
+template<typename E, typename A>
+void DynamicAssertionHelper::NotEquals(const E& not_expected,
+                                       const A& actual) {
+  if (actual != not_expected) return;
+  std::stringstream ness;
+  ness << not_expected;
+  std::string nes = ness.str();
+  Fail("did not expect: <%s>", nes.c_str());
+}
+
+
 template<typename E, typename A, typename T>
 void DynamicAssertionHelper::FloatEquals(const E& expected,
                                          const A& actual,
                                          const T& tol) {
   if (((expected - tol) <= actual) && (actual <= (expected + tol))) {
     return;
   }
   std::stringstream ess, ass, tolss;
   ess << expected;
   ass << actual;
@@ skipping 110 matching lines @@
 
 #if defined(TESTING)
 #define EXPECT(condition)                                                      \
   if (!(condition)) {                                                          \
     dart::Expect(__FILE__, __LINE__).Fail("expected: %s", #condition);         \
   }
 
 #define EXPECT_EQ(expected, actual)                                            \
   dart::Expect(__FILE__, __LINE__).Equals((expected), (actual))
 
+#define EXPECT_NE(not_expected, actual)                                        \
+  dart::Expect(__FILE__, __LINE__).NotEquals((not_expected), (actual))
+
 #define EXPECT_FLOAT_EQ(expected, actual, tol)                                 \
   dart::Expect(__FILE__, __LINE__).FloatEquals((expected), (actual), (tol))
 
 #define EXPECT_STREQ(expected, actual)                                         \
   dart::Expect(__FILE__, __LINE__).StringEquals((expected), (actual))
 
 #define EXPECT_LT(left, right)                                                 \
   dart::Expect(__FILE__, __LINE__).LessThan((left), (right))
 
 #define EXPECT_LE(left, right)                                                 \
@@ skipping 14 matching lines @@
 #define WARN(error)                                                           \
   dart::Expect(__FILE__, __LINE__).Fail("%s", error)
 
 #define WARN1(format, p1)                                                     \
   dart::Expect(__FILE__, __LINE__).Fail(format, (p1))
 
 #define WARN2(format, p1, p2)                                                 \
   dart::Expect(__FILE__, __LINE__).Fail(format, (p1), (p2))
 
 #endif  // VM_ASSERT_H_