bulk replace Isolate::Current in tests

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 119 matching lines @@
 };
 
 
 static void InitializeBuildingBlocks(Handle<String>* building_blocks,
                                      int bb_length,
                                      bool long_blocks,
                                      MyRandomNumberGenerator* rng,
                                      Zone* zone) {
   // 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.
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   for (int i = 0; i < bb_length; i++) {
     int len = rng->next(16);
     int slice_head_chars = 0;
     int slice_tail_chars = 0;
     int slice_depth = 0;
     for (int j = 0; j < 3; j++) {
       if (rng->next(0.35)) slice_depth++;
     }
     // Must truncate something for a slice string. Loop until
@@ skipping 132 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsStringGenerationData);
 };
 
 
 ConsStringGenerationData::ConsStringGenerationData(bool long_blocks,
                                                    Zone* zone) {
   rng_.init();
   InitializeBuildingBlocks(
       building_blocks_, kNumberOfBuildingBlocks, long_blocks, &rng_, zone);
-  empty_string_ = Isolate::Current()->heap()->empty_string();
+  empty_string_ = CcTest::i_isolate()->heap()->empty_string();
   Reset();
 }
 
 
 Handle<String> ConsStringGenerationData::block(uint32_t offset) {
   return building_blocks_[offset % kNumberOfBuildingBlocks ];
 }
 
 
 Handle<String> ConsStringGenerationData::block(int offset) {
@@ skipping 92 matching lines @@
   stats.left_traversals_ = data->stats_.left_traversals_;
   stats.right_traversals_ = data->stats_.right_traversals_;
   // Adjust total leaves to compensate.
   stats.leaves_ += stats.empty_leaves_;
   stats.VerifyEqual(data->stats_);
 }
 
 
 static Handle<String> ConstructRandomString(ConsStringGenerationData* data,
                                             unsigned max_recursion) {
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   // Compute termination characteristics.
   bool terminate = false;
   bool flat = data->rng_.next(data->empty_leaf_threshold_);
   bool terminate_early = data->rng_.next(data->early_termination_threshold_);
   if (terminate_early) data->early_terminations_++;
   // The obvious condition.
   terminate |= max_recursion == 0;
   // Flat cons string terminate by definition.
   terminate |= flat;
   // Cap for max leaves.
@@ skipping 41 matching lines @@
     FlattenString(root);
     CHECK(root->IsConsString() && root->IsFlat());
   }
   return root;
 }
 
 
 static Handle<String> ConstructLeft(
     ConsStringGenerationData* data,
     int depth) {
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   Handle<String> answer = factory->NewStringFromAscii(CStrVector(""));
   data->stats_.leaves_++;
   for (int i = 0; i < depth; i++) {
     Handle<String> block = data->block(i);
     Handle<String> next = factory->NewConsString(answer, block);
     if (next->IsConsString()) data->stats_.leaves_++;
     data->stats_.chars_ += block->length();
     answer = next;
   }
   data->stats_.left_traversals_ = data->stats_.leaves_ - 2;
   return answer;
 }
 
 
 static Handle<String> ConstructRight(
     ConsStringGenerationData* data,
     int depth) {
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   Handle<String> answer = factory->NewStringFromAscii(CStrVector(""));
   data->stats_.leaves_++;
   for (int i = depth - 1; i >= 0; i--) {
     Handle<String> block = data->block(i);
     Handle<String> next = factory->NewConsString(block, answer);
     if (next->IsConsString()) data->stats_.leaves_++;
     data->stats_.chars_ += block->length();
     answer = next;
   }
   data->stats_.right_traversals_ = data->stats_.leaves_ - 2;
   return answer;
 }
 
 
 static Handle<String> ConstructBalancedHelper(
     ConsStringGenerationData* data,
     int from,
     int to) {
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   CHECK(to > from);
   if (to - from == 1) {
     data->stats_.chars_ += data->block(from)->length();
     return data->block(from);
   }
   if (to - from == 2) {
     data->stats_.chars_ += data->block(from)->length();
     data->stats_.chars_ += data->block(from+1)->length();
     return factory->NewConsString(data->block(from), data->block(from+1));
   }
@@ skipping 48 matching lines @@
   }
   s1->Get(s1->length() - 1);
   s2->Get(s2->length() - 1);
 }
 
 
 TEST(Traverse) {
   printf("TestTraverse\n");
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
-  Zone zone(Isolate::Current());
+  Zone zone(CcTest::i_isolate());
   ConsStringGenerationData data(false, &zone);
   Handle<String> flat = ConstructBalanced(&data);
   FlattenString(flat);
   Handle<String> left_asymmetric = ConstructLeft(&data, DEEP_DEPTH);
   Handle<String> right_asymmetric = ConstructRight(&data, DEEP_DEPTH);
   Handle<String> symmetric = ConstructBalanced(&data);
   printf("1\n");
   Traverse(flat, symmetric);
   printf("2\n");
   Traverse(flat, left_asymmetric);
@@ skipping 67 matching lines @@
     "lefts", data.stats_.left_traversals_,
     "rights", data.stats_.right_traversals_,
     "early_terminations", data.early_terminations_);
 #endif
 }
 
 
 template<typename BuildString>
 void TestStringCharacterStream(BuildString build, int test_cases) {
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope outer_scope(isolate);
   Zone zone(isolate);
   ConsStringGenerationData data(true, &zone);
   for (int i = 0; i < test_cases; i++) {
     printf("%d\n", i);
     HandleScope inner_scope(isolate);
     AlwaysAllocateScope always_allocate;
     // Build flat version of cons string.
     Handle<String> flat_string = build(i, &data);
     ConsStringStats flat_string_stats;
@@ skipping 17 matching lines @@
     VerifyCharacterStream(flat_string_ptr, *cons_string);
   }
 }
 
 
 static const int kCharacterStreamNonRandomCases = 8;
 
 
 static Handle<String> BuildEdgeCaseConsString(
     int test_case, ConsStringGenerationData* data) {
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   data->Reset();
   switch (test_case) {
     case 0:
       return ConstructBalanced(data, 71);
     case 1:
       return ConstructLeft(data, 71);
     case 2:
       return ConstructRight(data, 71);
     case 3:
       return ConstructLeft(data, 10);
@@ skipping 142 matching lines @@
   TestStringCharacterStream(BuildRandomConsString, kUniqueRandomParameters*7);
 }
 
 
 static const int DEEP_ASCII_DEPTH = 100000;
 
 
 TEST(DeepAscii) {
   printf("TestDeepAscii\n");
   CcTest::InitializeVM();
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   v8::HandleScope scope(CcTest::isolate());
 
   char* foo = NewArray<char>(DEEP_ASCII_DEPTH);
   for (int i = 0; i < DEEP_ASCII_DEPTH; i++) {
     foo[i] = "foo "[i % 4];
   }
   Handle<String> string =
       factory->NewStringFromAscii(Vector<const char>(foo, DEEP_ASCII_DEPTH));
   Handle<String> foo_string = factory->NewStringFromAscii(CStrVector("foo"));
   for (int i = 0; i < DEEP_ASCII_DEPTH; i += 10) {
@@ skipping 49 matching lines @@
     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]);
   }
 }
 
 
 TEST(ExternalShortStringAdd) {
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   Zone zone(isolate);
 
   CcTest::InitializeVM();
   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.
@@ skipping 67 matching lines @@
     "    }"
     "  }"
     "  return 0;"
     "};"
     "test()";
   CHECK_EQ(0, CompileRun(source)->Int32Value());
 }
 
 
 TEST(JSONStringifySliceMadeExternal) {
-  Isolate* isolate = Isolate::Current();
+  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);"
@@ skipping 12 matching lines @@
 
   CHECK_EQ("\"bcdefghijklmnopqrstuvwxyz\"",
            *v8::String::Utf8Value(CompileRun("JSON.stringify(slice)")));
 }
 
 
 TEST(CachedHashOverflow) {
   // 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 = Isolate::Current();
+  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\";",
@@ skipping 26 matching lines @@
       CHECK_EQ(Smi::cast(results[i]->ToSmi()->ToObjectChecked())->value(),
                result->ToInt32()->Value());
     }
   }
 }
 
 
 TEST(SliceFromCons) {
   FLAG_string_slices = true;
   CcTest::InitializeVM();
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   v8::HandleScope scope(CcTest::isolate());
   Handle<String> string =
       factory->NewStringFromAscii(CStrVector("parentparentparent"));
   Handle<String> parent = factory->NewConsString(string, string);
   CHECK(parent->IsConsString());
   CHECK(!parent->IsFlat());
   Handle<String> slice = factory->NewSubString(parent, 1, 25);
   // After slicing, the original string becomes a flat cons.
   CHECK(parent->IsFlat());
   CHECK(slice->IsSlicedString());
@@ skipping 14 matching lines @@
   virtual size_t length() const { return data_.length(); }
   virtual const char* data() const { return data_.start(); }
  private:
   i::Vector<const char> data_;
 };
 
 
 TEST(SliceFromExternal) {
   FLAG_string_slices = true;
   CcTest::InitializeVM();
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   v8::HandleScope scope(CcTest::isolate());
   AsciiVectorResource resource(
       i::Vector<const char>("abcdefghijklmnopqrstuvwxyz", 26));
   Handle<String> string = factory->NewExternalStringFromAscii(&resource);
   CHECK(string->IsExternalString());
   Handle<String> slice = factory->NewSubString(string, 1, 25);
   CHECK(slice->IsSlicedString());
   CHECK(string->IsExternalString());
   CHECK_EQ(SlicedString::cast(*slice)->parent(), *string);
   CHECK(SlicedString::cast(*slice)->parent()->IsExternalString());
   CHECK(slice->IsFlat());
 }
 
 
 TEST(TrivialSlice) {
   // This tests whether a slice that contains the entire parent string
   // actually creates a new string (it should not).
   FLAG_string_slices = true;
   CcTest::InitializeVM();
-  Factory* factory = Isolate::Current()->factory();
+  Factory* factory = CcTest::i_isolate()->factory();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> result;
   Handle<String> string;
   const char* init = "var str = 'abcdefghijklmnopqrstuvwxyz';";
   const char* check = "str.slice(0,26)";
   const char* crosscheck = "str.slice(1,25)";
 
   CompileRun(init);
 
   result = CompileRun(check);
@@ skipping 212 matching lines @@
       CheckCanonicalEquivalence(c, test);
       continue;
     }
     if (upper != c && lower != c) {
       CheckCanonicalEquivalence(c, test);
       continue;
     }
     CHECK_EQ(Min(upper, lower), test);
   }
 }