Line data    Source code

       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include <stdint.h>
       6             : #include <stdlib.h>
       7             : #include <string.h>
       8             : 
       9             : #include "src/managed.h"
      10             : 
      11             : #include "src/objects-inl.h"
      12             : #include "test/cctest/cctest.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : class DeleteRecorder {
      18             :  public:
      19          24 :   explicit DeleteRecorder(bool* deleted) : deleted_(deleted) {
      20          24 :     *deleted_ = false;
      21             :   }
      22          24 :   ~DeleteRecorder() { *deleted_ = true; }
      23           6 :   static void Deleter(Isolate::ManagedObjectFinalizer* finalizer) {
      24          12 :     delete *reinterpret_cast<DeleteRecorder**>(finalizer);
      25           6 :   }
      26             : 
      27             :  private:
      28             :   bool* deleted_;
      29             : };
      30             : 
      31       23724 : TEST(ManagedCollect) {
      32           6 :   Isolate* isolate = CcTest::InitIsolateOnce();
      33           6 :   bool deleted1 = false;
      34           6 :   bool deleted2 = false;
      35           6 :   DeleteRecorder* d1 = new DeleteRecorder(&deleted1);
      36           6 :   DeleteRecorder* d2 = new DeleteRecorder(&deleted2);
      37             :   Isolate::ManagedObjectFinalizer finalizer(d2, DeleteRecorder::Deleter);
      38           6 :   isolate->RegisterForReleaseAtTeardown(&finalizer);
      39             :   {
      40             :     HandleScope scope(isolate);
      41           6 :     auto handle = Managed<DeleteRecorder>::From(isolate, d1);
      42             :     USE(handle);
      43             :   }
      44             : 
      45           6 :   CcTest::CollectAllAvailableGarbage();
      46             : 
      47           6 :   CHECK(deleted1);
      48           6 :   CHECK(!deleted2);
      49           6 :   isolate->UnregisterFromReleaseAtTeardown(&finalizer);
      50          12 :   delete d2;
      51           6 :   CHECK(deleted2);
      52           6 : }
      53             : 
      54       23724 : TEST(DisposeCollect) {
      55             :   v8::Isolate::CreateParams create_params;
      56             :   create_params.array_buffer_allocator =
      57           6 :       CcTest::InitIsolateOnce()->array_buffer_allocator();
      58             : 
      59           6 :   v8::Isolate* isolate = v8::Isolate::New(create_params);
      60           6 :   isolate->Enter();
      61             :   Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
      62           6 :   bool deleted1 = false;
      63           6 :   bool deleted2 = false;
      64           6 :   DeleteRecorder* d1 = new DeleteRecorder(&deleted1);
      65           6 :   DeleteRecorder* d2 = new DeleteRecorder(&deleted2);
      66             :   {
      67             :     HandleScope scope(i_isolate);
      68           6 :     auto handle = Managed<DeleteRecorder>::From(i_isolate, d1);
      69             :     USE(handle);
      70             :   }
      71             :   Isolate::ManagedObjectFinalizer finalizer(d2, DeleteRecorder::Deleter);
      72           6 :   i_isolate->RegisterForReleaseAtTeardown(&finalizer);
      73             : 
      74           6 :   isolate->Exit();
      75           6 :   isolate->Dispose();
      76           6 :   CHECK(deleted1);
      77           6 :   CHECK(deleted2);
      78           6 : }
      79             : 
      80             : }  // namespace internal
      81       71154 : }  // namespace v8