CSE2410 Fall 2014 Bounce

// Go through all incremental marking steps in one swoop.

static void SimulateIncrementalMarking() {

  if (collector->IsConcurrentSweepingInProgress()) {

    collector->WaitUntilSweepingCompleted();

  }

static void CheckMap(Map* map, int type, int instance_size) {

  CHECK(map->IsHeapObject());

#ifdef DEBUG

#endif

  CHECK_EQ(type, map->instance_type());

  CHECK_EQ(instance_size, map->instance_size());

}

TEST(HeapMaps) {

  CcTest::InitializeVM();

}

static void CheckNumber(Isolate* isolate, double value, const char* string) {

  CHECK(obj->IsNumber());

  bool exc;

  Handle<Object> handle(obj, isolate);

TEST(HeapObjects) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  Heap* heap = isolate->heap();

  CHECK(s->IsString());

  CHECK_EQ(10, s->length());

  // Check ToString for oddballs

  CheckOddball(isolate, heap->true_value(), "true");

TEST(GarbageCollection) {

  CcTest::InitializeVM();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  // Check GC.

  heap->CollectGarbage(NEW_SPACE);

  Handle<String> name = factory->InternalizeUtf8String("theFunction");

  Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");

  Handle<String> prop_namex = factory->InternalizeUtf8String("theSlotx");

  Handle<String> obj_name = factory->InternalizeUtf8String("theObject");

  {

    HandleScope inner_scope(isolate);

    Handle<Map> initial_map =

        factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);

    function->set_initial_map(*initial_map);

    // Allocate an object.  Unrooted after leaving the scope.

    Handle<JSObject> obj = factory->NewJSObject(function);

    CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));

    CHECK_EQ(Smi::FromInt(24), obj->GetProperty(*prop_namex));

  heap->CollectGarbage(NEW_SPACE);

  // Function should be alive.

  // Check function is retained.

      GetProperty(*name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

    HandleScope inner_scope(isolate);

    // Allocate another object, make it reachable from global.

    Handle<JSObject> obj = factory->NewJSObject(function);

  }

  // After gc, it should survive.

  heap->CollectGarbage(NEW_SPACE);

        GetProperty(*obj_name)->ToObjectChecked()->IsJSObject());

      GetProperty(*obj_name)->ToObjectChecked();

  JSObject* js_obj = JSObject::cast(obj);

  CHECK_EQ(Smi::FromInt(23), js_obj->GetProperty(*prop_name));

TEST(LocalHandles) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

TEST(GlobalHandles) {

  CcTest::InitializeVM();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

TEST(WeakGlobalHandlesScavenge) {

  i::FLAG_stress_compaction = false;

  CcTest::InitializeVM();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

TEST(WeakGlobalHandlesMark) {

  CcTest::InitializeVM();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

TEST(DeleteWeakGlobalHandle) {

  i::FLAG_stress_compaction = false;

  CcTest::InitializeVM();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

static void CheckInternalizedStrings(const char** strings) {

  for (const char* string = *strings; *strings != 0; string = *strings++) {

    Object* a;

    // InternalizeUtf8String may return a failure if a GC is needed.

    if (!maybe_a->ToObject(&a)) continue;

    CHECK(a->IsInternalizedString());

    Object* b;

    if (!maybe_b->ToObject(&b)) continue;

    CHECK_EQ(b, a);

    CHECK(String::cast(b)->IsUtf8EqualTo(CStrVector(string)));

TEST(FunctionAllocation) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

      factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);

  function->set_initial_map(*initial_map);

  Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");

  Handle<JSObject> obj = factory->NewJSObject(function);

  CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));

  // Check that we can add properties to function objects.

  CHECK_EQ(Smi::FromInt(24), function->GetProperty(*prop_name));

}

TEST(ObjectProperties) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

      GetProperty(object_string)->ToObjectChecked();

  JSFunction* object_function = JSFunction::cast(raw_object);

  Handle<JSFunction> constructor(object_function);

  Handle<String> first = factory->InternalizeUtf8String("first");

  Handle<String> second = factory->InternalizeUtf8String("second");

  // check for empty

  // add first

  // delete first

  JSReceiver::DeleteProperty(obj, first, JSReceiver::NORMAL_DELETION);

  // add first and then second

  // delete first and then second

  JSReceiver::DeleteProperty(obj, first, JSReceiver::NORMAL_DELETION);

  JSReceiver::DeleteProperty(obj, second, JSReceiver::NORMAL_DELETION);

  // add first and then second

  // delete second and then first

  JSReceiver::DeleteProperty(obj, second, JSReceiver::NORMAL_DELETION);

  JSReceiver::DeleteProperty(obj, first, JSReceiver::NORMAL_DELETION);

  // check string and internalized string match

  const char* string1 = "fisk";

  Handle<String> s1 = factory->NewStringFromAscii(CStrVector(string1));

  Handle<String> s1_string = factory->InternalizeUtf8String(string1);

  // check internalized string and string match

  const char* string2 = "fugl";

  Handle<String> s2_string = factory->InternalizeUtf8String(string2);

  Handle<String> s2 = factory->NewStringFromAscii(CStrVector(string2));

}

TEST(JSObjectMaps) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  Handle<JSObject> obj = factory->NewJSObject(function);

  // Set a propery

  CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));

  // Check the map has changed

TEST(JSArray) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  Handle<String> name = factory->InternalizeUtf8String("Array");

      GetProperty(*name)->ToObjectChecked();

  Handle<JSFunction> function = Handle<JSFunction>(

      JSFunction::cast(raw_object));

TEST(JSObjectCopy) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

      GetProperty(object_string)->ToObjectChecked();

  JSFunction* object_function = JSFunction::cast(raw_object);

  Handle<JSFunction> constructor(object_function);

  Handle<String> first = factory->InternalizeUtf8String("first");

  Handle<String> second = factory->InternalizeUtf8String("second");

  obj->SetElement(0, *first, NONE, kNonStrictMode)->ToObjectChecked();

  obj->SetElement(1, *second, NONE, kNonStrictMode)->ToObjectChecked();

  // Make the clone.

  CHECK(!clone.is_identical_to(obj));

  CHECK_EQ(obj->GetElement(isolate, 0), clone->GetElement(isolate, 0));

  CHECK_EQ(obj->GetProperty(*second), clone->GetProperty(*second));

  // Flip the values.

  clone->SetElement(0, *second, NONE, kNonStrictMode)->ToObjectChecked();

  clone->SetElement(1, *first, NONE, kNonStrictMode)->ToObjectChecked();

TEST(StringAllocation) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  const unsigned char chars[] = { 0xe5, 0xa4, 0xa7 };

TEST(Iteration) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  objs[next_objs_index++] = Handle<Map>(HeapObject::cast(*objs[0])->map());

  CHECK_EQ(objs_count, next_objs_index);

}

TEST(Regression39128) {

  // Test case for crbug.com/39128.

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  // Increase the chance of 'bump-the-pointer' allocation in old space.

  v8::HandleScope scope(CcTest::isolate());

  // Step 1: prepare a map for the object.  We add 1 inobject property to it.

  Handle<JSFunction> object_ctor(

  CHECK(object_ctor->has_initial_map());

  Handle<Map> object_map(object_ctor->initial_map());

  // Create a map with single inobject property.

  int allocation_amount = Min(FixedArray::kMaxSize,

                              Page::kMaxNonCodeHeapObjectSize + kPointerSize);

  int allocation_len = LenFromSize(allocation_amount);

  Address* top_addr = new_space->allocation_top_address();

  Address* limit_addr = new_space->allocation_limit_address();

  while ((*limit_addr - *top_addr) > allocation_amount) {

    CHECK(!array->IsFailure());

    CHECK(new_space->Contains(array));

  }

  int fixed_array_len = LenFromSize(to_fill);

  CHECK(fixed_array_len < FixedArray::kMaxLength);

  CHECK(!array->IsFailure());

  CHECK(new_space->Contains(array));

  CHECK(new_space->Contains(object));

  JSObject* jsobject = JSObject::cast(object);

  CHECK_EQ(0, FixedArray::cast(jsobject->elements())->length());

  // Step 4: clone jsobject, but force always allocate first to create a clone

  // in old pointer space.

  AlwaysAllocateScope aa_scope;

  JSObject* clone = JSObject::cast(clone_obj);

  if (clone->address() != old_pointer_space_top) {

    // Alas, got allocated from free list, we cannot do checks.

    return;

  }

}

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code) return;

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "function foo() {"

  }

  // Check function is compiled.

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  // The code will survive at least two GCs.

  CHECK(function->shared()->is_compiled());

  // Simulate several GCs that use full marking.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

  }

  // foo should no longer be in the compilation cache

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return;

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "function foo() {"

  }

  // Check function is compiled.

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  // The code will survive at least two GCs.

  CHECK(function->shared()->is_compiled());

  // Simulate several GCs that use incremental marking.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

    SimulateIncrementalMarking();

  }

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  CHECK(!function->is_compiled() || function->IsOptimized());

  for (int i = 0; i < kAgingThreshold; i++) {

    SimulateIncrementalMarking();

    if (!function->next_function_link()->IsUndefined()) break;

  }

  // Force optimization while incremental marking is active and while

  }

  // Simulate one final GC to make sure the candidate queue is sane.

  CHECK(function->shared()->is_compiled() || !function->IsOptimized());

  CHECK(function->is_compiled() || !function->IsOptimized());

}

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return;

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "var foo = function() {"

  Handle<String> bar_name = factory->InternalizeUtf8String("bar");

  // Perfrom one initial GC to enable code flushing.

  // This compile will add the code to the compilation cache.

  { v8::HandleScope scope(CcTest::isolate());

  }

  // Check functions are compiled.

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

      GetProperty(*bar_name)->ToObjectChecked();

  CHECK(func_value2->IsJSFunction());

  Handle<JSFunction> function2(JSFunction::cast(func_value2));

  // perform a scavenge while incremental marking is still running.

  SimulateIncrementalMarking();

  *function2.location() = NULL;

  // Simulate one final GC to make sure the candidate queue is sane.

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  CHECK(!function->is_compiled() || function->IsOptimized());

}

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return;

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  Heap* heap = isolate->heap();

  v8::HandleScope scope(CcTest::isolate());

  }

  // Check function is compiled.

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

// Count the number of native contexts in the weak list of native contexts.

int CountNativeContexts() {

  int count = 0;

  while (!object->IsUndefined()) {

    count++;

    object = Context::cast(object)->get(Context::NEXT_CONTEXT_LINK);

  static const int kNumTestContexts = 10;

  Heap* heap = isolate->heap();

  HandleScope scope(isolate);

  v8::Handle<v8::Context> ctx[kNumTestContexts];

  // Create a number of global contests which gets linked together.

  for (int i = 0; i < kNumTestContexts; i++) {

    // Collect garbage that might have been created by one of the

    // installed extensions.

    // Scavenge treats these references as strong.

    for (int j = 0; j < 10; j++) {

      CHECK_EQ(opt ? 5 : 0, CountOptimizedUserFunctions(ctx[i]));

    }

    // Get rid of f3 and f5 in the same way.

    CompileRun("f3=null");

    for (int j = 0; j < 10; j++) {

      CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctions(ctx[i]));

    }

    CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctions(ctx[i]));

    CompileRun("f5=null");

    for (int j = 0; j < 10; j++) {

      CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctions(ctx[i]));

    }

    CHECK_EQ(opt ? 2 : 0, CountOptimizedUserFunctions(ctx[i]));

    ctx[i]->Exit();

  }

  // Force compilation cache cleanup.

  // Dispose the native contexts one by one.

  for (int i = 0; i < kNumTestContexts; i++) {

    // TODO(dcarney): is there a better way to do this?

    i::Object** unsafe = reinterpret_cast<i::Object**>(*ctx[i]);

    ctx[i].Clear();

    // Scavenge treats these references as strong.

    for (int j = 0; j < 10; j++) {

      CHECK_EQ(kNumTestContexts - i, CountNativeContexts());

    }

    // Mark compact handles the weak references.

    CHECK_EQ(kNumTestContexts - i - 1, CountNativeContexts());

  }

TEST(TestInternalWeakListsTraverseWithGC) {

  v8::V8::Initialize();

  static const int kNumTestContexts = 10;

  // Create an number of contexts and check the length of the weak list both

  // with and without GCs while iterating the list.

  for (int i = 0; i < kNumTestContexts; i++) {

    CHECK_EQ(i + 1, CountNativeContexts());

    CHECK_EQ(i + 1, CountNativeContextsWithGC(isolate, i / 2 + 1));

  }

  // Get initial heap size after several full GCs, which will stabilize

  // the heap size and return with sweeping finished completely.

  {

    // Allocate objects on several different old-space pages so that

    AlwaysAllocateScope always_allocate;

    int filler_size = static_cast<int>(FixedArray::SizeFor(8192));

    for (int i = 1; i <= 100; i++) {

      CHECK_EQ(initial_size + i * filler_size,

    }

  }

  // The heap size should go back to initial size after a full GC, even

  // though sweeping didn't finish yet.

  // Normally sweeping would not be complete here, but no guarantees.

  // Advancing the sweeper step-wise should not change the heap size.

  }

}

TEST(TestSizeOfObjectsVsHeapIteratorPrecision) {

  CcTest::InitializeVM();

  intptr_t size_of_objects_2 = 0;

  for (HeapObject* obj = iterator.next();

       obj != NULL;

TEST(GrowAndShrinkNewSpace) {

  CcTest::InitializeVM();

    // The max size cannot exceed the reserved size, since semispaces must be

    // always within the reserved space.  We can't test new space growing and

    // shrinking if the reserved size is the same as the minimum (initial) size.

  CHECK(old_capacity == new_capacity);

  // Let the scavenger empty the new space.

  CHECK_LE(new_space->Size(), old_capacity);

  // Explicitly shrinking should halve the space capacity.

TEST(CollectingAllAvailableGarbageShrinksNewSpace) {

  CcTest::InitializeVM();

    // The max size cannot exceed the reserved size, since semispaces must be

    // always within the reserved space.  We can't test new space growing and

    // shrinking if the reserved size is the same as the minimum (initial) size.

  }

  v8::HandleScope scope(CcTest::isolate());

  intptr_t old_capacity, new_capacity;

  old_capacity = new_space->Capacity();

  new_space->Grow();

  new_capacity = new_space->Capacity();

  CHECK(2 * old_capacity == new_capacity);

  FillUpNewSpace(new_space);

  new_capacity = new_space->Capacity();

  CHECK(old_capacity == new_capacity);

}

static int NumberOfGlobalObjects() {

  int count = 0;

  for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {

    if (obj->IsGlobalObject()) count++;

  }

// optimized code.

TEST(LeakNativeContextViaMap) {

  i::FLAG_allow_natives_syntax = true;

  v8::HandleScope outer_scope(isolate);

  v8::Persistent<v8::Context> ctx1p;

  v8::Persistent<v8::Context> ctx2p;

    v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();

  }

  CHECK_EQ(4, NumberOfGlobalObjects());

  {

    ctx1p.Dispose();

    v8::V8::ContextDisposedNotification();

  }

  CHECK_EQ(2, NumberOfGlobalObjects());

  ctx2p.Dispose();

  CHECK_EQ(0, NumberOfGlobalObjects());

}

// optimized code.

TEST(LeakNativeContextViaFunction) {

  i::FLAG_allow_natives_syntax = true;

  v8::HandleScope outer_scope(isolate);

  v8::Persistent<v8::Context> ctx1p;

  v8::Persistent<v8::Context> ctx2p;

    v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();

  }

  CHECK_EQ(4, NumberOfGlobalObjects());

  {

    ctx1p.Dispose();

    v8::V8::ContextDisposedNotification();

  }

  CHECK_EQ(2, NumberOfGlobalObjects());

  ctx2p.Dispose();

  CHECK_EQ(0, NumberOfGlobalObjects());

}

TEST(LeakNativeContextViaMapKeyed) {

  i::FLAG_allow_natives_syntax = true;

  v8::HandleScope outer_scope(isolate);

  v8::Persistent<v8::Context> ctx1p;

  v8::Persistent<v8::Context> ctx2p;

    v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();

  }

  CHECK_EQ(4, NumberOfGlobalObjects());

  {

    ctx1p.Dispose();

    v8::V8::ContextDisposedNotification();

  }

  CHECK_EQ(2, NumberOfGlobalObjects());

  ctx2p.Dispose();

  CHECK_EQ(0, NumberOfGlobalObjects());

}

TEST(LeakNativeContextViaMapProto) {

  i::FLAG_allow_natives_syntax = true;

  v8::HandleScope outer_scope(isolate);

  v8::Persistent<v8::Context> ctx1p;

  v8::Persistent<v8::Context> ctx2p;

    v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();

  }

  CHECK_EQ(4, NumberOfGlobalObjects());

  {

    ctx1p.Dispose();

    v8::V8::ContextDisposedNotification();

  }

  CHECK_EQ(2, NumberOfGlobalObjects());

  ctx2p.Dispose();

  CHECK_EQ(0, NumberOfGlobalObjects());

}

#endif

  CcTest::InitializeVM();

  if (i::FLAG_force_marking_deque_overflows) return;

  {

    CompileRun(

        "function foo () { }"

        "function mkbar () { return new (new Function(\"\")) (); }"

        "f(new foo()); g();");

  }

  marking->Abort();

  marking->Start();

  Handle<JSFunction> f =

      v8::Utils::OpenHandle(

          *v8::Handle<v8::Function>::Cast(

  CHECK(f->IsOptimized());

  CHECK(marking->IsMarking());

  {

    v8::Handle<v8::Function> g =

        v8::Handle<v8::Function>::Cast(global->Get(v8_str("g")));

    g->Call(global, 0, NULL);

  }

}

TEST(PrototypeTransitionClearing) {

  CcTest::InitializeVM();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  Handle<JSObject> baseObject =

      v8::Utils::OpenHandle(

          *v8::Handle<v8::Object>::Cast(

  // Verify that only dead prototype transitions are cleared.

  CHECK_EQ(10, baseObject->map()->NumberOfProtoTransitions());

  const int transitions = 10 - 3;

  CHECK_EQ(transitions, baseObject->map()->NumberOfProtoTransitions());

  // Make sure next prototype is placed on an old-space evacuation candidate.

  Handle<JSObject> prototype;

  {

    AlwaysAllocateScope always_allocate;

    SimulateFullSpace(space);

  CHECK(space->LastPage()->Contains(prototype->address()));

  JSObject::SetPrototype(baseObject, prototype, false);

  CHECK(Map::GetPrototypeTransition(map, prototype)->IsMap());

  CHECK(Map::GetPrototypeTransition(map, prototype)->IsMap());

}

#endif

  CcTest::InitializeVM();

  {

    CompileRun(

        "function f () {"

        "  var s = 0;"

  Handle<JSFunction> f =

      v8::Utils::OpenHandle(

          *v8::Handle<v8::Function>::Cast(

  CHECK(f->IsOptimized());

  marking->Abort();

  marking->Start();

  const int kLongIdlePauseInMs = 1000;

  v8::V8::ContextDisposedNotification();

  v8::V8::IdleNotification(kLongIdlePauseInMs);

    // guard interrupt.  But here we didn't ask for that, and there is no

    // JS code running to trigger the interrupt, so we explicitly finalize

    // here.

                            "Test finalizing incremental mark-sweep");

  }

  CHECK_EQ(0, f->shared()->opt_count());

  CHECK_EQ(0, f->shared()->code()->profiler_ticks());

}

#endif

  CcTest::InitializeVM();

  v8::HandleScope outer_scope(CcTest::isolate());

  {

  Handle<JSFunction> f =

      v8::Utils::OpenHandle(

          *v8::Handle<v8::Function>::Cast(

  CHECK(f->IsOptimized());

  // Since incremental marking is off, IdleNotification will do full GC.

  const int kLongIdlePauseInMs = 1000;

  v8::V8::ContextDisposedNotification();

  v8::V8::IdleNotification(kLongIdlePauseInMs);

  CHECK_EQ(0, f->shared()->opt_count());

  CHECK_EQ(0, f->shared()->code()->profiler_ticks());

}

TEST(OptimizedAllocationAlwaysInNewSpace) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  AlwaysAllocateScope always_allocate;

  v8::Local<v8::Value> res = CompileRun(

      "function c(x) {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

}

TEST(OptimizedPretenuringAllocationFolding) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function DataObject() {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

}

TEST(OptimizedPretenuringAllocationFoldingBlocks) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function DataObject() {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

}

TEST(OptimizedPretenuringObjectArrayLiterals) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function f() {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

}

TEST(OptimizedPretenuringMixedInObjectProperties) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function f() {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

  JSObject* inner_object = reinterpret_cast<JSObject*>(o->RawFastPropertyAt(0));

}

TEST(OptimizedPretenuringDoubleArrayProperties) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function f() {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

}

TEST(OptimizedPretenuringdoubleArrayLiterals) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function f() {"

  Handle<JSObject> o =

      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));

}

TEST(OptimizedPretenuringNestedMixedArrayLiterals) {

  i::FLAG_allow_natives_syntax = true;

  CcTest::InitializeVM();

  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> res = CompileRun(

      "function f() {"