PPAPI: Implement PPB_FileMapping on POSIX

ppapi/tests/test_case.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PPAPI_TESTS_TEST_CASE_H_
 #define PPAPI_TESTS_TEST_CASE_H_
 
 #include <cmath>
 #include <limits>
 #include <map>
 #include <set>
+#include <sstream>
 #include <string>
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/private/ppb_testing_private.h"
 #include "ppapi/cpp/dev/scrollbar_dev.h"
 #include "ppapi/cpp/message_loop.h"
 #include "ppapi/cpp/view.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
@@ skipping 244 matching lines @@
  private:
   friend class TestingInstance;
 
   TestCaseFactory* next_;
   const char* name_;
   Method method_;
 
   static TestCaseFactory* head_;
 };
 
+
+// This is an implementation detail, for use by ASSERT macros.
+template <class T>
+struct StringinatorBase {
+  static std::string ToString(const T& value, const std::string& s) {
+    std::stringstream stream;
+    stream << value;
+    return s + "(" + stream.str() + ")";
+  }
+ private:
+  // Not implemented, do not use.
+  StringinatorBase();
+  ~StringinatorBase();
+};
+// The default version is for types that are not known to be stringifiable.
+// TODO(dmichael): Are there some useful traits for this?
+template <class T>
+struct Stringinator {
+  static std::string ToString(const T& value, const std::string& s) {
+    return s;
+  }
+ private:
+  // Not implemented, do not use.
+  Stringinator();
+  ~Stringinator();
+};
+#define STRINGINATOR_FOR_TYPE(type) \
+template <> \
+struct Stringinator<type> : public StringinatorBase<type> {};
+STRINGINATOR_FOR_TYPE(int32_t);
+STRINGINATOR_FOR_TYPE(uint32_t);
+STRINGINATOR_FOR_TYPE(int64_t);
+STRINGINATOR_FOR_TYPE(uint64_t);
+STRINGINATOR_FOR_TYPE(float);
+STRINGINATOR_FOR_TYPE(double);
+STRINGINATOR_FOR_TYPE(bool);
+STRINGINATOR_FOR_TYPE(std::string);
+//TODO(dmichael): Put this somewhere else
+template <class T>
+std::string ToString(const T& param, const char* s) {
+  return Stringinator<T>::ToString(param, std::string(s));
+}
+// This overload is necessary to allow values from pp_errors.h such as PP_OK to
+// work. They won't automatically convert to an integral type to instantiate the
+// above template.
+inline std::string ToString(int32_t param, const char* s) {
+  return Stringinator<int32_t>::ToString(param, std::string(s));
+}
+#define TO_STRING(param) ToString(param, #param)
+
 // Use the REGISTER_TEST_CASE macro in your TestCase implementation file to
 // register your TestCase.  If your test is named TestFoo, then add the
 // following to test_foo.cc:
 //
 //   REGISTER_TEST_CASE(Foo);
 //
 // This will cause your test to be included in the set of known tests.
 //
 #define REGISTER_TEST_CASE(name)                                            \
   static TestCase* Test##name##_FactoryMethod(TestingInstance* instance) {  \
@@ skipping 80 matching lines @@
 //                 cleanly. crbug.com/173503
 
 // Helper macros for checking values in tests, and returning a location
 // description of the test fails.
 #define ASSERT_TRUE(cmd) \
   do { \
     if (!(cmd)) \
       return MakeFailureMessage(__FILE__, __LINE__, #cmd); \
   } while (false)
 #define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd))
-#define ASSERT_EQ(a, b) ASSERT_TRUE((a) == (b))
+#define ASSERT_BINARY_INTERNAL(a, op, b) \
+  do { \
+    if (!((a) op (b))) \
+      return MakeFailureMessage(__FILE__, __LINE__, \
+          (TO_STRING((a)) + " " #op " " + TO_STRING((b))).c_str()); \
+  } while (false)
+#define ASSERT_EQ(a, b) ASSERT_BINARY_INTERNAL((a), ==, (b))
 #define ASSERT_NE(a, b) ASSERT_TRUE((a) != (b))
 #define ASSERT_LT(a, b) ASSERT_TRUE((a) < (b))
 #define ASSERT_LE(a, b) ASSERT_TRUE((a) <= (b))
 #define ASSERT_GT(a, b) ASSERT_TRUE((a) > (b))
 #define ASSERT_GE(a, b) ASSERT_TRUE((a) >= (b))
 
 #define ASSERT_DOUBLE_EQ(a, b) ASSERT_TRUE( \
     std::fabs((a)-(b)) <= std::numeric_limits<double>::epsilon())
 
 // Runs |function| as a subtest and asserts that it has passed.
 #define ASSERT_SUBTEST_SUCCESS(function) \
   do { \
     std::string result = (function); \
     if (!result.empty()) \
       return result; \
   } while (false)
 
 #define PASS() return std::string()
 
 #endif  // PPAPI_TESTS_TEST_CASE_H_