| // Copyright (c) 2012, 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 RUNTIME_PLATFORM_ASSERT_H_ |
| #define RUNTIME_PLATFORM_ASSERT_H_ |
| |
| #include "platform/globals.h" |
| |
| #if !defined(DEBUG) && !defined(NDEBUG) |
| #error neither DEBUG nor NDEBUG defined |
| #elif defined(DEBUG) && defined(NDEBUG) |
| #error both DEBUG and NDEBUG defined |
| #endif |
| |
| // 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() |
| #if defined(DEBUG) || defined(TESTING) |
| #include <string.h> |
| |
| #include <sstream> |
| #include <string> |
| #endif |
| |
| namespace dart { |
| |
| class DynamicAssertionHelper { |
| public: |
| DynamicAssertionHelper(const char* file, int line) |
| : file_(file), line_(line) {} |
| |
| protected: |
| void Print(const char* format, |
| va_list arguments, |
| bool will_abort = false) const; |
| |
| const char* const file_; |
| const int line_; |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(DynamicAssertionHelper); |
| }; |
| |
| class Assert : public DynamicAssertionHelper { |
| public: |
| Assert(const char* file, int line) : DynamicAssertionHelper(file, line) {} |
| |
| DART_NORETURN void Fail(const char* format, ...) const PRINTF_ATTRIBUTE(2, 3); |
| |
| template <typename T> |
| T NotNull(const T p); |
| }; |
| |
| class Expect : public DynamicAssertionHelper { |
| public: |
| Expect(const char* file, int line) : DynamicAssertionHelper(file, line) {} |
| |
| void Fail(const char* format, ...) const PRINTF_ATTRIBUTE(2, 3); |
| |
| #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> |
| void BitEquals(const E& expected, const A& actual); |
| |
| template <typename E, typename A, typename T> |
| void FloatEquals(const E& expected, const A& actual, const T& tol); |
| |
| void StringEquals(const char* expected, const char* actual); |
| |
| void IsSubstring(const char* needle, const char* haystack); |
| |
| void IsNotSubstring(const char* needle, const char* haystack); |
| |
| template <typename E, typename A> |
| void LessThan(const E& left, const A& right); |
| |
| template <typename E, typename A> |
| void LessEqual(const E& left, const A& right); |
| |
| template <typename E, typename A> |
| void GreaterThan(const E& left, const A& right); |
| |
| template <typename E, typename A> |
| void GreaterEqual(const E& left, const A& right); |
| |
| template <typename T> |
| void NotNull(const T p); |
| |
| template <typename T> |
| void Null(const T p); |
| #endif |
| |
| static bool failed() { return failed_; } |
| |
| private: |
| static bool failed_; |
| }; |
| |
| template <typename T> |
| T Assert::NotNull(const T p) { |
| if (p != nullptr) return p; |
| Fail("expected: not nullptr, found nullptr"); |
| return nullptr; |
| } |
| |
| #if defined(TESTING) |
| // Only allow the expensive (with respect to code size) assertions |
| // in testing code. |
| template <typename E, typename A> |
| void Expect::Equals(const E& expected, const A& actual) { |
| if (actual == expected) return; |
| std::ostringstream 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 Expect::NotEquals(const E& not_expected, const A& actual) { |
| if (actual != not_expected) return; |
| std::ostringstream ness; |
| ness << not_expected; |
| std::string nes = ness.str(); |
| Fail("did not expect: <%s>", nes.c_str()); |
| } |
| |
| template <typename E, typename A> |
| void Expect::BitEquals(const E& expected, const A& actual) { |
| static_assert(sizeof(E) == sizeof(A)); |
| if (memcmp(&expected, &actual, sizeof(E)) == 0) return; |
| std::ostringstream 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, typename T> |
| void Expect::FloatEquals(const E& expected, const A& actual, const T& tol) { |
| if (((expected - tol) <= actual) && (actual <= (expected + tol))) { |
| return; |
| } |
| std::ostringstream ess, ass, tolss; |
| ess << expected; |
| ass << actual; |
| tolss << tol; |
| std::string es = ess.str(), as = ass.str(), tols = tolss.str(); |
| Fail("expected: <%s> but was: <%s> (tolerance: <%s>)", es.c_str(), as.c_str(), |
| tols.c_str()); |
| } |
| |
| static void Escape(std::string& dst, const char* src, int len) { |
| if (len == 0) return; |
| const char* const end = src + len; |
| for (char c = *src; src < end; src++, c = *src) { |
| if (c == '\n') { |
| dst += "\\n\"\n\""; |
| } else if (c == '\'') { |
| dst += "\\\'"; |
| } else if (c == '\"') { |
| dst += "\\\""; |
| } else if (c == '\\') { |
| dst += "\\\\"; |
| } else if (c == '\0') { |
| dst += "\\0"; |
| } else { |
| dst += c; |
| } |
| } |
| } |
| |
| // Splits two null-terminated strings into a common prefix and suffix |
| // and the mismatched parts of the two strings, escaping the outputs. |
| // |
| // If the two strings are the same, then an escaped version of |
| // the string is in the prefix and the other outputs are empty. |
| // |
| // If there is no common prefix and suffix or the size of the common |
| // prefix and suffix combined is small in comparison to the size |
| // of the two strings, then the prefix and suffix are empty to limit |
| // the noise in the output of Expect::StringEquals. |
| static void FindCommonPrefixAndSuffix(const char* expected, |
| const char* actual, |
| std::string& prefix, |
| std::string& expected_mismatch, |
| std::string& actual_mismatch, |
| std::string& suffix) { |
| const int expected_len = strlen(expected); |
| const int actual_len = strlen(actual); |
| int prefix_length = 0; |
| while (expected[prefix_length] == actual[prefix_length]) { |
| // Either the prefix or actual string is a prefix of the other. |
| if (expected[prefix_length] == '\0' || actual[prefix_length] == '\0') { |
| break; |
| } |
| prefix_length += 1; |
| } |
| |
| if (prefix_length == expected_len && prefix_length == actual_len) { |
| // The two are equal, so just escape the whole string into the prefix. |
| Escape(prefix, expected, prefix_length); |
| return; |
| } |
| |
| int suffix_length = 0; |
| while (expected[(expected_len - 1) - suffix_length] == |
| actual[(actual_len - 1) - suffix_length]) { |
| if (prefix_length + suffix_length == expected_len || |
| prefix_length + suffix_length == actual_len) { |
| // The prefix and suffix cover the entirety of one of the |
| // two strings, meaning the actual string either has missing |
| // or extra contents compared to the expected string. |
| break; |
| } |
| suffix_length += 1; |
| } |
| |
| // Set a minimum difference required to output a non-empty prefix and suffix, |
| // so that they are not output if the common prefix and suffix of the expected |
| // and actual strings is small. |
| constexpr int kMinDifference = 10; |
| if (prefix_length + suffix_length < kMinDifference) { |
| prefix_length = 0; |
| suffix_length = 0; |
| } |
| |
| Escape(prefix, expected, prefix_length); |
| Escape(expected_mismatch, expected + prefix_length, |
| expected_len - prefix_length - suffix_length); |
| Escape(actual_mismatch, actual + prefix_length, |
| actual_len - prefix_length - suffix_length); |
| Escape(suffix, expected + expected_len - suffix_length, suffix_length); |
| } |
| |
| inline void Expect::StringEquals(const char* expected, const char* actual) { |
| if (actual == nullptr) { |
| Fail("expected:\n<\"%s\">\nbut was nullptr", expected); |
| } else { |
| if (strcmp(expected, actual) == 0) return; |
| std::string prefix, expected_mismatch, actual_mismatch, suffix; |
| FindCommonPrefixAndSuffix(expected, actual, prefix, expected_mismatch, |
| actual_mismatch, suffix); |
| // Only print the prefix and/or suffix if non-empty. |
| if (prefix.empty() && suffix.empty()) { |
| Fail("expected:\n<\"%s\">\nbut was:\n<\"%s\">", expected_mismatch.c_str(), |
| actual_mismatch.c_str()); |
| } else if (prefix.empty()) { |
| Fail( |
| "substring mismatch:\nexpected:\n <\"%s\">\nbut was:\n " |
| "<\"%s\">\nsuffix:\n <\"%s\">", |
| expected_mismatch.c_str(), actual_mismatch.c_str(), suffix.c_str()); |
| } else if (suffix.empty()) { |
| Fail("prefix:\n <\"%s\">\nexpected:\n <\"%s\">\nbut was:\n <\"%s\">", |
| prefix.c_str(), expected_mismatch.c_str(), actual_mismatch.c_str()); |
| } else { |
| Fail( |
| "prefix:\n <\"%s\">\nexpected:\n <\"%s\">\nbut was:\n " |
| "<\"%s\">\nsuffix:\n <\"%s\">", |
| prefix.c_str(), expected_mismatch.c_str(), actual_mismatch.c_str(), |
| suffix.c_str()); |
| } |
| } |
| } |
| |
| inline void Expect::IsSubstring(const char* needle, const char* haystack) { |
| if (strstr(haystack, needle) != nullptr) return; |
| Fail("expected <\"%s\"> to be a substring of <\"%s\">", needle, haystack); |
| } |
| |
| inline void Expect::IsNotSubstring(const char* needle, const char* haystack) { |
| if (strstr(haystack, needle) == nullptr) return; |
| Fail("expected <\"%s\"> to not be a substring of <\"%s\">", needle, haystack); |
| } |
| |
| template <typename E, typename A> |
| void Expect::LessThan(const E& left, const A& right) { |
| if (left < right) return; |
| std::ostringstream ess, ass; |
| ess << left; |
| ass << right; |
| std::string es = ess.str(), as = ass.str(); |
| Fail("expected: %s < %s", es.c_str(), as.c_str()); |
| } |
| |
| template <typename E, typename A> |
| void Expect::LessEqual(const E& left, const A& right) { |
| if (left <= right) return; |
| std::ostringstream ess, ass; |
| ess << left; |
| ass << right; |
| std::string es = ess.str(), as = ass.str(); |
| Fail("expected: %s <= %s", es.c_str(), as.c_str()); |
| } |
| |
| template <typename E, typename A> |
| void Expect::GreaterThan(const E& left, const A& right) { |
| if (left > right) return; |
| std::ostringstream ess, ass; |
| ess << left; |
| ass << right; |
| std::string es = ess.str(), as = ass.str(); |
| Fail("expected: %s > %s", es.c_str(), as.c_str()); |
| } |
| |
| template <typename E, typename A> |
| void Expect::GreaterEqual(const E& left, const A& right) { |
| if (left >= right) return; |
| std::ostringstream ess, ass; |
| ess << left; |
| ass << right; |
| std::string es = ess.str(), as = ass.str(); |
| Fail("expected: %s >= %s", es.c_str(), as.c_str()); |
| } |
| |
| template <typename T> |
| void Expect::NotNull(const T p) { |
| if (p != nullptr) return; |
| Fail("expected: not nullptr, found nullptr"); |
| } |
| |
| template <typename T> |
| void Expect::Null(const T p) { |
| if (p == nullptr) return; |
| Fail("expected: nullptr, found not null pointer"); |
| } |
| #endif |
| |
| } // namespace dart |
| |
| #define FATAL(format, ...) \ |
| dart::Assert(__FILE__, __LINE__).Fail(format, ##__VA_ARGS__); |
| |
| #define UNIMPLEMENTED() FATAL("unimplemented code") |
| |
| #define UNREACHABLE() FATAL("unreachable code") |
| |
| #define OUT_OF_MEMORY() FATAL("Out of memory.") |
| |
| #if defined(DEBUG) |
| // DEBUG binaries use assertions in the code. |
| // Note: We wrap the if statement in a do-while so that we get a compile |
| // error if there is no semicolon after ASSERT(condition). This |
| // ensures that we get the same behavior on DEBUG and RELEASE builds. |
| |
| #define ASSERT(cond) \ |
| do { \ |
| if (!(cond)) dart::Assert(__FILE__, __LINE__).Fail("expected: %s", #cond); \ |
| } while (false) |
| |
| #define ASSERT_EQUAL(actual, expected) \ |
| do { \ |
| if ((expected) != (actual)) { \ |
| const std::string actual_str = std::to_string(actual); \ |
| const std::string expected_str = std::to_string(expected); \ |
| dart::Assert(__FILE__, __LINE__) \ |
| .Fail("expected \"%s\" = %s, actual \"%s\" = %s", #expected, \ |
| expected_str.c_str(), #actual, actual_str.c_str()); \ |
| } \ |
| } while (false) |
| |
| #define ASSERT_LESS_OR_EQUAL(actual, expected) \ |
| do { \ |
| if ((actual) > (expected)) { \ |
| const std::string actual_str = std::to_string(actual); \ |
| const std::string expected_str = std::to_string(expected); \ |
| dart::Assert(__FILE__, __LINE__) \ |
| .Fail("expected \"%s\" = %s >= actual \"%s\" = %s", #expected, \ |
| expected_str.c_str(), #actual, actual_str.c_str()); \ |
| } \ |
| } while (false) |
| |
| #define ASSERT_IMPLIES(antecedent, consequent) \ |
| do { \ |
| if (antecedent) { \ |
| ASSERT(consequent); \ |
| } \ |
| } while (false) |
| |
| // DEBUG_ASSERT allows identifiers in condition to be undeclared in release |
| // mode. |
| #define DEBUG_ASSERT(cond) ASSERT(cond) |
| |
| // Returns 'ptr'; useful for initializer lists: |
| // class Foo { Foo(int* ptr) : ptr_(ASSERT_NOTNULL(ptr)) ... |
| #define ASSERT_NOTNULL(ptr) dart::Assert(__FILE__, __LINE__).NotNull((ptr)) |
| |
| #else // if defined(DEBUG) |
| |
| // In order to avoid variable unused warnings for code that only uses |
| // a variable in an ASSERT or EXPECT, we make sure to use the macro |
| // argument. |
| #define ASSERT(condition) \ |
| do { \ |
| } while (false && (condition)) |
| |
| #define ASSERT_EQUAL(expected, actual) \ |
| do { \ |
| } while (false && ((expected) != (actual))) |
| |
| #define ASSERT_LESS_OR_EQUAL(expected, actual) \ |
| do { \ |
| } while (false && ((actual) > (expected))) |
| |
| #define ASSERT_IMPLIES(antecedent, consequent) \ |
| do { \ |
| } while (false && (!(antecedent) || (consequent))) |
| |
| #define DEBUG_ASSERT(cond) |
| |
| #define ASSERT_NOTNULL(ptr) (ptr) |
| |
| #endif // if defined(DEBUG) |
| |
| #define RELEASE_ASSERT(cond) \ |
| do { \ |
| if (!(cond)) dart::Assert(__FILE__, __LINE__).Fail("expected: %s", #cond); \ |
| } while (false) |
| |
| #define RELEASE_ASSERT_WITH_MSG(cond, msg) \ |
| do { \ |
| if (!(cond)) { \ |
| dart::Assert(__FILE__, __LINE__).Fail("%s: expected: %s", msg, #cond); \ |
| } \ |
| } while (false) |
| |
| #define COMPILE_ASSERT(expr) static_assert(expr, "") |
| |
| #if defined(TESTING) |
| |
| // EXPECT and FAIL are equivalent to ASSERT and FATAL except that they do not |
| // cause early termination of the unit test. This allows testing to proceed |
| // further to be able to report other failures before reporting the overall |
| // unit tests as failing. |
| |
| #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_BITEQ(expected, actual) \ |
| dart::Expect(__FILE__, __LINE__).BitEquals((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_SUBSTRING(needle, haystack) \ |
| dart::Expect(__FILE__, __LINE__).IsSubstring((needle), (haystack)) |
| |
| #define EXPECT_NOTSUBSTRING(needle, haystack) \ |
| dart::Expect(__FILE__, __LINE__).IsNotSubstring((needle), (haystack)) |
| |
| #define EXPECT_LT(left, right) \ |
| dart::Expect(__FILE__, __LINE__).LessThan((left), (right)) |
| |
| #define EXPECT_LE(left, right) \ |
| dart::Expect(__FILE__, __LINE__).LessEqual((left), (right)) |
| |
| #define EXPECT_GT(left, right) \ |
| dart::Expect(__FILE__, __LINE__).GreaterThan((left), (right)) |
| |
| #define EXPECT_GE(left, right) \ |
| dart::Expect(__FILE__, __LINE__).GreaterEqual((left), (right)) |
| |
| #define EXPECT_NOTNULL(ptr) dart::Expect(__FILE__, __LINE__).NotNull((ptr)) |
| |
| #define EXPECT_NULLPTR(ptr) dart::Expect(__FILE__, __LINE__).Null((ptr)) |
| |
| #define FAIL(format, ...) \ |
| dart::Expect(__FILE__, __LINE__).Fail(format, ##__VA_ARGS__) |
| |
| #endif // defined(TESTING) |
| |
| #endif // RUNTIME_PLATFORM_ASSERT_H_ |
