[test] Move cctest/test-dictionary to unittests/

... objects/dictionary-unittest.

Bug: v8:12781
Change-Id: I7faeb9fedf7857b25a85bf32f14323ba3da207c0
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3706968Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: 王澳 <wangao.james@bytedance.com>
Cr-Commit-Position: refs/heads/main@{#81395}

test/cctest/BUILD.gn

@@ -179,7 +179,6 @@ v8_source_set("cctest_sources") {
     "test-debug-helper.cc",
     "test-debug.cc",
     "test-descriptor-array.cc",
-    "test-dictionary.cc",
     "test-disasm-regex-helper.cc",
     "test-disasm-regex-helper.h",
     "test-feedback-vector.cc",

test/unittests/BUILD.gn

@@ -426,6 +426,7 @@ v8_source_set("unittests_sources") {
     "objects/concurrent-script-context-table-unittest.cc",
     "objects/concurrent-string-unittest.cc",
     "objects/concurrent-transition-array-unittest.cc",
+    "objects/dictionary-unittest.cc",
     "objects/elements-kind-unittest.cc",
     "objects/global-object-unittest.cc",
     "objects/hashcode-unittest.cc",

test/unittests/heap/heap-utils.cc

@@ -38,5 +38,120 @@ void HeapInternalsBase::SimulateIncrementalMarking(Heap* heap,
   CHECK(marking->IsComplete());
 }
 
+void HeapInternalsBase::SimulateFullSpace(
+    v8::internal::NewSpace* space,
+    std::vector<Handle<FixedArray>>* out_handles) {
+  // If you see this check failing, disable the flag at the start of your test:
+  // FLAG_stress_concurrent_allocation = false;
+  // Background thread allocating concurrently interferes with this function.
+  CHECK(!FLAG_stress_concurrent_allocation);
+  while (FillCurrentPage(space, out_handles) || space->AddFreshPage()) {
+  }
+}
+
+void HeapInternalsBase::SimulateFullSpace(v8::internal::PagedSpace* space) {
+  // If you see this check failing, disable the flag at the start of your test:
+  // FLAG_stress_concurrent_allocation = false;
+  // Background thread allocating concurrently interferes with this function.
+  CHECK(!FLAG_stress_concurrent_allocation);
+  CodePageCollectionMemoryModificationScopeForTesting code_scope(space->heap());
+  i::MarkCompactCollector* collector = space->heap()->mark_compact_collector();
+  if (collector->sweeping_in_progress()) {
+    collector->EnsureSweepingCompleted(
+        MarkCompactCollector::SweepingForcedFinalizationMode::kV8Only);
+  }
+  space->FreeLinearAllocationArea();
+  space->ResetFreeList();
+}
+
+bool HeapInternalsBase::FillCurrentPage(
+    v8::internal::NewSpace* space,
+    std::vector<Handle<FixedArray>>* out_handles) {
+  return FillCurrentPageButNBytes(space, 0, out_handles);
+}
+
+namespace {
+int GetSpaceRemainingOnCurrentPage(v8::internal::NewSpace* space) {
+  Address top = space->top();
+  if ((top & kPageAlignmentMask) == 0) {
+    // `top` points to the start of a page signifies that there is not room in
+    // the current page.
+    return 0;
+  }
+  return static_cast<int>(Page::FromAddress(space->top())->area_end() - top);
+}
+}  // namespace
+
+bool HeapInternalsBase::FillCurrentPageButNBytes(
+    v8::internal::NewSpace* space, int extra_bytes,
+    std::vector<Handle<FixedArray>>* out_handles) {
+  PauseAllocationObserversScope pause_observers(space->heap());
+  // We cannot rely on `space->limit()` to point to the end of the current page
+  // in the case where inline allocations are disabled, it actually points to
+  // the current allocation pointer.
+  DCHECK_IMPLIES(!space->IsInlineAllocationEnabled(),
+                 space->limit() == space->top());
+  int space_remaining = GetSpaceRemainingOnCurrentPage(space);
+  CHECK(space_remaining >= extra_bytes);
+  int new_linear_size = space_remaining - extra_bytes;
+  if (new_linear_size == 0) return false;
+  std::vector<Handle<FixedArray>> handles =
+      CreatePadding(space->heap(), space_remaining, i::AllocationType::kYoung);
+  if (out_handles != nullptr) {
+    out_handles->insert(out_handles->end(), handles.begin(), handles.end());
+  }
+  return true;
+}
+
+int HeapInternalsBase::FixedArrayLenFromSize(int size) {
+  return std::min({(size - FixedArray::kHeaderSize) / kTaggedSize,
+                   FixedArray::kMaxRegularLength});
+}
+
+std::vector<Handle<FixedArray>> HeapInternalsBase::CreatePadding(
+    Heap* heap, int padding_size, AllocationType allocation, int object_size) {
+  std::vector<Handle<FixedArray>> handles;
+  Isolate* isolate = heap->isolate();
+  int allocate_memory;
+  int length;
+  int free_memory = padding_size;
+  if (allocation == i::AllocationType::kOld) {
+    heap->old_space()->FreeLinearAllocationArea();
+    int overall_free_memory = static_cast<int>(heap->old_space()->Available());
+    CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
+  } else {
+    int overall_free_memory = static_cast<int>(heap->new_space()->Available());
+    CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
+  }
+  while (free_memory > 0) {
+    if (free_memory > object_size) {
+      allocate_memory = object_size;
+      length = FixedArrayLenFromSize(allocate_memory);
+    } else {
+      allocate_memory = free_memory;
+      length = FixedArrayLenFromSize(allocate_memory);
+      if (length <= 0) {
+        // Not enough room to create another FixedArray, so create a filler.
+        if (allocation == i::AllocationType::kOld) {
+          heap->CreateFillerObjectAt(
+              *heap->old_space()->allocation_top_address(), free_memory);
+        } else {
+          heap->CreateFillerObjectAt(
+              *heap->new_space()->allocation_top_address(), free_memory);
+        }
+        break;
+      }
+    }
+    handles.push_back(isolate->factory()->NewFixedArray(length, allocation));
+    CHECK((allocation == AllocationType::kYoung &&
+           heap->new_space()->Contains(*handles.back())) ||
+          (allocation == AllocationType::kOld &&
+           heap->InOldSpace(*handles.back())) ||
+          FLAG_single_generation);
+    free_memory -= handles.back()->Size();
+  }
+  return handles;
+}
+
 }  // namespace internal
 }  // namespace v8

test/unittests/heap/heap-utils.h

@@ -17,6 +17,19 @@ namespace internal {
 class HeapInternalsBase {
  protected:
   void SimulateIncrementalMarking(Heap* heap, bool force_completion);
+  void SimulateFullSpace(
+      v8::internal::NewSpace* space,
+      std::vector<Handle<FixedArray>>* out_handles = nullptr);
+  void SimulateFullSpace(v8::internal::PagedSpace* space);
+  bool FillCurrentPageButNBytes(
+      v8::internal::NewSpace* space, int extra_bytes,
+      std::vector<Handle<FixedArray>>* out_handles = nullptr);
+  bool FillCurrentPage(v8::internal::NewSpace* space,
+                       std::vector<Handle<FixedArray>>* out_handles = nullptr);
+  std::vector<Handle<FixedArray>> CreatePadding(
+      Heap* heap, int padding_size, AllocationType allocation,
+      int object_size = kMaxRegularHeapObjectSize);
+  int FixedArrayLenFromSize(int size);
 };
 
 template <typename TMixin>
@@ -44,6 +57,15 @@ class WithHeapInternals : public TMixin, HeapInternalsBase {
     return HeapInternalsBase::SimulateIncrementalMarking(heap(),
                                                          force_completion);
   }
+
+  void SimulateFullSpace(
+      v8::internal::NewSpace* space,
+      std::vector<Handle<FixedArray>>* out_handles = nullptr) {
+    return HeapInternalsBase::SimulateFullSpace(space, out_handles);
+  }
+  void SimulateFullSpace(v8::internal::PagedSpace* space) {
+    return HeapInternalsBase::SimulateFullSpace(space);
+  }
 };
 
 using TestWithHeapInternals =                  //