Fixed some memory leaks in unit tests.

test/cctest/test-api.cc

 // Copyright 2007-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 99 matching lines @@
 // pseudorandomly select a successor thread and switch execution
 // to that thread, suspending the current test.
 class ApiTestFuzzer: public v8::internal::Thread {
  public:
   void CallTest();
   explicit ApiTestFuzzer(int num)
       : test_number_(num),
         gate_(v8::internal::OS::CreateSemaphore(0)),
         active_(true) {
   }
+  ~ApiTestFuzzer() { delete gate_; }
 
   // The ApiTestFuzzer is also a Thread, so it has a Run method.
   virtual void Run();
 
   enum PartOfTest { FIRST_PART, SECOND_PART };
 
   static void Setup(PartOfTest part);
   static void RunAllTests();
   static void TearDown();
   // This method switches threads if we are running the Threading test.
@@ skipping 5429 matching lines @@
 THREADED_TEST(AccessChecksReenabledCorrectly) {
   v8::HandleScope scope;
   LocalContext context;
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessCheckCallbacks(NamedGetAccessBlocker,
                                  IndexedGetAccessBlocker);
   templ->Set(v8_str("a"), v8_str("a"));
   // Add more than 8 (see kMaxFastProperties) properties
   // so that the constructor will force copying map.
   // Cannot sprintf, gcc complains unsafety.
-  char buf[5];
+  char buf[4];
   for (char i = '0'; i <= '9' ; i++) {
-    buf[1] = i;
+    buf[0] = i;
     for (char j = '0'; j <= '9'; j++) {
-      buf[2] = j;
+      buf[1] = j;
       for (char k = '0'; k <= '9'; k++) {
-        buf[3] = k;
-        buf[4] = 0;
+        buf[2] = k;
+        buf[3] = 0;
         templ->Set(v8_str(buf), v8::Number::New(k));
       }
     }
   }
 
   Local<v8::Object> instance_1 = templ->NewInstance();
   context->Global()->Set(v8_str("obj_1"), instance_1);
 
   Local<Value> value_1 = CompileRun("obj_1.a");
   CHECK(value_1->IsUndefined());
@@ skipping 27 matching lines @@
 // without initializing the whole VM. Thus we cannot run this test in a
 // multi-threaded setup.
 TEST(PreCompile) {
   // TODO(155): This test would break without the initialization of V8. This is
   // a workaround for now to make this test not fail.
   v8::V8::Initialize();
   const char *script = "function foo(a) { return a+1; }";
   v8::ScriptData *sd = v8::ScriptData::PreCompile(script, strlen(script));
   CHECK_NE(sd->Length(), 0);
   CHECK_NE(sd->Data(), NULL);
+  delete sd;
 }
 
 
 // This tests that we do not allow dictionary load/call inline caches
 // to use functions that have not yet been compiled.  The potential
 // problem of loading a function that has not yet been compiled can
 // arise because we share code between contexts via the compilation
 // cache.
 THREADED_TEST(DictionaryICLoadedFunction) {
   v8::HandleScope scope;
@@ skipping 61 matching lines @@
 
     LongRunningRegExp();
     {
       v8::Unlocker unlock;
       gc_thread.Join();
     }
     v8::Locker::StopPreemption();
     CHECK(regexp_success_);
     CHECK(gc_success_);
   }
+  RegExpInterruptTest() : block_(NULL) {}
+  ~RegExpInterruptTest() { delete block_; }
  private:
   // Number of garbage collections required.
   static const int kRequiredGCs = 5;
 
   class GCThread : public i::Thread {
    public:
     explicit GCThread(RegExpInterruptTest* test)
         : test_(test) {}
     virtual void Run() {
       test_->CollectGarbage();
@@ skipping 77 matching lines @@
 
   // Local context should still be live.
   CHECK(!local_env.IsEmpty());
   local_env->Enter();
 
   // Should complete without problems.
   RegExpInterruptTest().RunTest();
 
   local_env->Exit();
 }