src/3rdparty/v8/test/cctest/cctest.h

   1 // Copyright 2008 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #ifndef CCTEST_H_
  29 #define CCTEST_H_
  30
  31 #include "v8.h"
  32
  33 #ifndef TEST
  34 #define TEST(Name)                                                       \
  35   static void Test##Name();                                              \
  36   CcTest register_test_##Name(Test##Name, __FILE__, #Name, NULL, true);  \
  37   static void Test##Name()
  38 #endif
  39
  40 #ifndef DEPENDENT_TEST
  41 #define DEPENDENT_TEST(Name, Dep)                                        \
  42   static void Test##Name();                                              \
  43   CcTest register_test_##Name(Test##Name, __FILE__, #Name, #Dep, true);  \
  44   static void Test##Name()
  45 #endif
  46
  47 #ifndef DISABLED_TEST
  48 #define DISABLED_TEST(Name)                                              \
  49   static void Test##Name();                                              \
  50   CcTest register_test_##Name(Test##Name, __FILE__, #Name, NULL, false); \
  51   static void Test##Name()
  52 #endif
  53
  54 class CcTest {
  55  public:
  56   typedef void (TestFunction)();
  57   CcTest(TestFunction* callback, const char* file, const char* name,
  58          const char* dependency, bool enabled);
  59   void Run() { callback_(); }
  60   static int test_count();
  61   static CcTest* last() { return last_; }
  62   CcTest* prev() { return prev_; }
  63   const char* file() { return file_; }
  64   const char* name() { return name_; }
  65   const char* dependency() { return dependency_; }
  66   bool enabled() { return enabled_; }
  67  private:
  68   TestFunction* callback_;
  69   const char* file_;
  70   const char* name_;
  71   const char* dependency_;
  72   bool enabled_;
  73   static CcTest* last_;
  74   CcTest* prev_;
  75 };
  76
  77 // Switches between all the Api tests using the threading support.
  78 // In order to get a surprising but repeatable pattern of thread
  79 // switching it has extra semaphores to control the order in which
  80 // the tests alternate, not relying solely on the big V8 lock.
  81 //
  82 // A test is augmented with calls to ApiTestFuzzer::Fuzz() in its
  83 // callbacks.  This will have no effect when we are not running the
  84 // thread fuzzing test.  In the thread fuzzing test it will
  85 // pseudorandomly select a successor thread and switch execution
  86 // to that thread, suspending the current test.
  87 class ApiTestFuzzer: public v8::internal::Thread {
  88  public:
  89   void CallTest();
  90   explicit ApiTestFuzzer(int num)
  91       : Thread("ApiTestFuzzer"),
  92         test_number_(num),
  93         gate_(v8::internal::OS::CreateSemaphore(0)),
  94         active_(true) {
  95   }
  96   ~ApiTestFuzzer() { delete gate_; }
  97
  98   // The ApiTestFuzzer is also a Thread, so it has a Run method.
  99   virtual void Run();
 100
 101   enum PartOfTest { FIRST_PART,
 102                     SECOND_PART,
 103                     THIRD_PART,
 104                     FOURTH_PART,
 105                     LAST_PART = FOURTH_PART };
 106
 107   static void SetUp(PartOfTest part);
 108   static void RunAllTests();
 109   static void TearDown();
 110   // This method switches threads if we are running the Threading test.
 111   // Otherwise it does nothing.
 112   static void Fuzz();
 113
 114  private:
 115   static bool fuzzing_;
 116   static int tests_being_run_;
 117   static int current_;
 118   static int active_tests_;
 119   static bool NextThread();
 120   int test_number_;
 121   v8::internal::Semaphore* gate_;
 122   bool active_;
 123   void ContextSwitch();
 124   static int GetNextTestNumber();
 125   static v8::internal::Semaphore* all_tests_done_;
 126 };
 127
 128
 129 #define THREADED_TEST(Name)                                          \
 130   static void Test##Name();                                          \
 131   RegisterThreadedTest register_##Name(Test##Name, #Name);           \
 132   /* */ TEST(Name)
 133
 134
 135 class RegisterThreadedTest {
 136  public:
 137   explicit RegisterThreadedTest(CcTest::TestFunction* callback,
 138                                 const char* name)
 139       : fuzzer_(NULL), callback_(callback), name_(name) {
 140     prev_ = first_;
 141     first_ = this;
 142     count_++;
 143   }
 144   static int count() { return count_; }
 145   static RegisterThreadedTest* nth(int i) {
 146     CHECK(i < count());
 147     RegisterThreadedTest* current = first_;
 148     while (i > 0) {
 149       i--;
 150       current = current->prev_;
 151     }
 152     return current;
 153   }
 154   CcTest::TestFunction* callback() { return callback_; }
 155   ApiTestFuzzer* fuzzer_;
 156   const char* name() { return name_; }
 157
 158  private:
 159   static RegisterThreadedTest* first_;
 160   static int count_;
 161   CcTest::TestFunction* callback_;
 162   RegisterThreadedTest* prev_;
 163   const char* name_;
 164 };
 165
 166
 167 // A LocalContext holds a reference to a v8::Context.
 168 class LocalContext {
 169  public:
 170   LocalContext(v8::ExtensionConfiguration* extensions = 0,
 171                v8::Handle<v8::ObjectTemplate> global_template =
 172                    v8::Handle<v8::ObjectTemplate>(),
 173                v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>())
 174     : context_(v8::Context::New(extensions, global_template, global_object)) {
 175     context_->Enter();
 176   }
 177
 178   virtual ~LocalContext() {
 179     context_->Exit();
 180     context_.Dispose();
 181   }
 182
 183   v8::Context* operator->() { return *context_; }
 184   v8::Context* operator*() { return *context_; }
 185   bool IsReady() { return !context_.IsEmpty(); }
 186
 187   v8::Local<v8::Context> local() {
 188     return v8::Local<v8::Context>::New(context_);
 189   }
 190
 191  private:
 192   v8::Persistent<v8::Context> context_;
 193 };
 194
 195
 196 static inline v8::Local<v8::Value> v8_num(double x) {
 197   return v8::Number::New(x);
 198 }
 199
 200
 201 static inline v8::Local<v8::String> v8_str(const char* x) {
 202   return v8::String::New(x);
 203 }
 204
 205
 206 static inline v8::Local<v8::Script> v8_compile(const char* x) {
 207   return v8::Script::Compile(v8_str(x));
 208 }
 209
 210
 211 // Helper function that compiles and runs the source.
 212 static inline v8::Local<v8::Value> CompileRun(const char* source) {
 213   return v8::Script::Compile(v8::String::New(source))->Run();
 214 }
 215
 216
 217 #endif  // ifndef CCTEST_H_