Fixed test memory leaks

test/cctest/test-strings.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 
 // Check that we can traverse very deep stacks of ConsStrings using
 // StringInputBuffer.  Check that Get(int) works on very deep stacks
 // of ConsStrings.  These operations may not be very fast, but they
 // should be possible without getting errors due to too deep recursion.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "factory.h"
 #include "cctest.h"
+#include "zone-inl.h"
 
 unsigned int seed = 123;
 
 static uint32_t gen() {
         uint64_t z;
         z = seed;
         z *= 279470273;
         z %= 4294967291U;
         seed = static_cast<unsigned int>(z);
         return static_cast<uint32_t>(seed >> 16);
@@ skipping 17 matching lines @@
 }
 
 
 static const int NUMBER_OF_BUILDING_BLOCKS = 128;
 static const int DEEP_DEPTH = 8 * 1024;
 static const int SUPER_DEEP_DEPTH = 80 * 1024;
 
 
 static void InitializeBuildingBlocks(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
+  // A list of pointers that we don't have any interest in cleaning up.
+  // If they are reachable from a root then leak detection won't complain.
   for (int i = 0; i < NUMBER_OF_BUILDING_BLOCKS; i++) {
     int len = gen() % 16;
     if (len > 14) {
       len += 1234;
     }
     switch (gen() % 4) {
       case 0: {
         uc16 buf[2000];
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 65536;
@@ skipping 12 matching lines @@
         }
         building_blocks[i] =
             Factory::NewStringFromAscii(Vector<const char>(buf, len));
         for (int j = 0; j < len; j++) {
           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
       case 2: {
         class Resource: public v8::String::ExternalStringResource,
-                        public Malloced {
+                        public ZoneObject {
          public:
           explicit Resource(Vector<const uc16> string): data_(string.start()) {
             length_ = string.length();
           }
           virtual const uint16_t* data() const { return data_; }
           virtual size_t length() const { return length_; }
 
          private:
           const uc16* data_;
           size_t length_;
         };
-        uc16* buf = NewArray<uc16>(len);
+        uc16* buf = Zone::NewArray<uc16>(len);
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 65536;
         }
         Resource* resource = new Resource(Vector<const uc16>(buf, len));
         building_blocks[i] = Factory::NewExternalStringFromTwoByte(resource);
         for (int j = 0; j < len; j++) {
           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
@@ skipping 99 matching lines @@
   s1->Get(s1->length() - 1);
   s2->Get(s2->length() - 1);
 }
 
 
 TEST(Traverse) {
   printf("TestTraverse\n");
   InitializeVM();
   v8::HandleScope scope;
   Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS];
+  ZoneScope zone(DELETE_ON_EXIT);
   InitializeBuildingBlocks(building_blocks);
   Handle<String> flat = ConstructBalanced(building_blocks);
   FlattenString(flat);
   Handle<String> left_asymmetric = ConstructLeft(building_blocks, DEEP_DEPTH);
   Handle<String> right_asymmetric = ConstructRight(building_blocks, DEEP_DEPTH);
   Handle<String> symmetric = ConstructBalanced(building_blocks);
   printf("1\n");
   Traverse(flat, symmetric);
   printf("2\n");
   Traverse(flat, left_asymmetric);
@@ skipping 71 matching lines @@
     return branch;
   return(SliceOf(branch));
 }
 
 
 TEST(Slice) {
   printf("TestSlice\n");
   InitializeVM();
   v8::HandleScope scope;
   Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS];
+  ZoneScope zone(DELETE_ON_EXIT);
   InitializeBuildingBlocks(building_blocks);
 
   seed = 42;
   Handle<String> slice_tree =
       ConstructSliceTree(building_blocks, 0, DEEP_DEPTH);
   seed = 42;
   Handle<String> flat_slice_tree =
       ConstructSliceTree(building_blocks, 0, DEEP_DEPTH);
   FlattenString(flat_slice_tree);
   Traverse(flat_slice_tree, slice_tree);
@@ skipping 59 matching lines @@
     int written = mixed->WriteUtf8(buffer, i);
     CHECK_EQ(lengths[i], written);
     // Check that the contents are correct
     for (int j = 0; j < lengths[i]; j++)
       CHECK_EQ(as_utf8[j], static_cast<unsigned char>(buffer[j]));
     // Check that the rest of the buffer hasn't been touched
     for (int j = lengths[i]; j < 11; j++)
       CHECK_EQ(kNoChar, buffer[j]);
   }
 }