cleanup cctest generally and remove ctest::context

test/cctest/test-strings.cc

 // Copyright 2012 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 915 matching lines @@
     for (int j = lengths[i]; j < 11; j++)
       CHECK_EQ(kNoChar, buffer[j]);
   }
 }
 
 
 TEST(ExternalShortStringAdd) {
   Isolate* isolate = CcTest::i_isolate();
   Zone zone(isolate);
 
-  CcTest::InitializeVM();
+  LocalContext context;
   v8::HandleScope handle_scope(CcTest::isolate());
 
   // Make sure we cover all always-flat lengths and at least one above.
   static const int kMaxLength = 20;
   CHECK_GT(kMaxLength, i::ConsString::kMinLength);
 
   // Allocate two JavaScript arrays for holding short strings.
   v8::Handle<v8::Array> ascii_external_strings =
       v8::Array::New(kMaxLength + 1);
   v8::Handle<v8::Array> non_ascii_external_strings =
@@ skipping 20 matching lines @@
     // Terminating '\0' is left out on purpose. It is not required for external
     // string data.
     Resource* resource = new(&zone) Resource(Vector<const uc16>(non_ascii, i));
     v8::Local<v8::String> non_ascii_external_string =
       v8::String::NewExternal(resource);
     non_ascii_external_strings->Set(v8::Integer::New(i),
                                     non_ascii_external_string);
   }
 
   // Add the arrays with the short external strings in the global object.
-  v8::Handle<v8::Object> global = CcTest::env()->Global();
+  v8::Handle<v8::Object> global = context->Global();
   global->Set(v8_str("external_ascii"), ascii_external_strings);
   global->Set(v8_str("external_non_ascii"), non_ascii_external_strings);
   global->Set(v8_str("max_length"), v8::Integer::New(kMaxLength));
 
   // Add short external ascii and non-ascii strings checking the result.
   static const char* source =
     "function test() {"
     "  var ascii_chars = 'aaaaaaaaaaaaaaaaaaaa';"
     "  var non_ascii_chars = '\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234';"  //NOLINT
     "  if (ascii_chars.length != max_length) return 1;"
@@ skipping 23 matching lines @@
     "    }"
     "  }"
     "  return 0;"
     "};"
     "test()";
   CHECK_EQ(0, CompileRun(source)->Int32Value());
 }
 
 
 TEST(JSONStringifySliceMadeExternal) {
+  CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Zone zone(isolate);
-  CcTest::InitializeVM();
   // Create a sliced string from a one-byte string.  The latter is turned
   // into a two-byte external string.  Check that JSON.stringify works.
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::Handle<v8::String> underlying =
       CompileRun("var underlying = 'abcdefghijklmnopqrstuvwxyz';"
                  "underlying")->ToString();
   v8::Handle<v8::String> slice =
       CompileRun("var slice = underlying.slice(1);"
                  "slice")->ToString();
   CHECK(v8::Utils::OpenHandle(*slice)->IsSlicedString());
   CHECK(v8::Utils::OpenHandle(*underlying)->IsSeqOneByteString());
 
   int length = underlying->Length();
   uc16* two_byte = zone.NewArray<uc16>(length + 1);
   underlying->Write(two_byte);
   Resource* resource =
       new(&zone) Resource(Vector<const uc16>(two_byte, length));
   CHECK(underlying->MakeExternal(resource));
   CHECK(v8::Utils::OpenHandle(*slice)->IsSlicedString());
   CHECK(v8::Utils::OpenHandle(*underlying)->IsExternalTwoByteString());
 
   CHECK_EQ("\"bcdefghijklmnopqrstuvwxyz\"",
            *v8::String::Utf8Value(CompileRun("JSON.stringify(slice)")));
 }
 
 
 TEST(CachedHashOverflow) {
+  CcTest::InitializeVM();
   // We incorrectly allowed strings to be tagged as array indices even if their
   // values didn't fit in the hash field.
   // See http://code.google.com/p/v8/issues/detail?id=728
   Isolate* isolate = CcTest::i_isolate();
   Zone zone(isolate);
 
-  CcTest::InitializeVM();
   v8::HandleScope handle_scope(CcTest::isolate());
   // Lines must be executed sequentially. Combining them into one script
   // makes the bug go away.
   const char* lines[] = {
       "var x = [];",
       "x[4] = 42;",
       "var s = \"1073741828\";",
       "x[s];",
       "x[s] = 37;",
       "x[4];",
@@ skipping 311 matching lines @@
       CheckCanonicalEquivalence(c, test);
       continue;
     }
     if (upper != c && lower != c) {
       CheckCanonicalEquivalence(c, test);
       continue;
     }
     CHECK_EQ(Min(upper, lower), test);
   }
 }