test: verify heap buffer allocations occur

Check that small typed arrays, including `Buffer`s (unless allocated
by `Buffer.allocUnsafe()`), are indeed heap-allocated.
PR-URL: #26301
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: addaleax

src/node_util.cc

@@ -8,6 +8,7 @@ namespace util {
 
 using v8::ALL_PROPERTIES;
 using v8::Array;
+using v8::ArrayBufferView;
 using v8::Boolean;
 using v8::Context;
 using v8::Function;
@@ -174,6 +175,11 @@ void WatchdogHasPendingSigint(const FunctionCallbackInfo<Value>& args) {
  args.GetReturnValue().Set(ret);
 }
 
+voidArrayBufferViewHasBuffer(const FunctionCallbackInfo<Value>& args) {
+CHECK(args[0]->IsArrayBufferView());
+ args.GetReturnValue().Set(args[0].As<ArrayBufferView>()->HasBuffer());
+}
+
 voidEnqueueMicrotask(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Isolate* isolate = env->isolate();
@@ -254,6 +260,7 @@ void Initialize(Local<Object> target,
  env->SetMethodNoSideEffect(target, "watchdogHasPendingSigint",
  WatchdogHasPendingSigint);
 
+ env->SetMethod(target, "arrayBufferViewHasBuffer", ArrayBufferViewHasBuffer);
  env->SetMethod(target, "enqueueMicrotask", EnqueueMicrotask);
  env->SetMethod(target, "triggerFatalException", FatalException);
  Local<Object> constants = Object::New(env->isolate());

test/parallel/test-buffer-backing-arraybuffer.js

@@ -0,0 +1,37 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+constassert=require('assert');
+const{ internalBinding }=require('internal/test/binding');
+const{ arrayBufferViewHasBuffer }=internalBinding('util');
+
+consttests=[
+{length: 0,expectOnHeap: true},
+{length: 48,expectOnHeap: true},
+{length: 96,expectOnHeap: false},
+{length: 1024,expectOnHeap: false},
+];
+
+for(const{ length, expectOnHeap }oftests){
+constarrays=[
+newUint8Array(length),
+newUint16Array(length/2),
+newUint32Array(length/4),
+newFloat32Array(length/4),
+newFloat64Array(length/8),
+Buffer.alloc(length),
+Buffer.allocUnsafeSlow(length)
+// Buffer.allocUnsafe() is missing because it may use pooled allocations.
+];
+
+for(constarrayofarrays){
+constisOnHeap=!arrayBufferViewHasBuffer(array);
+assert.strictEqual(isOnHeap,expectOnHeap,
+`mismatch: ${isOnHeap} vs ${expectOnHeap} `+
+`for ${array.constructor.name}, length = ${length}`);
+
+// Consistency check: Accessing .buffer should create it.
+array.buffer;
+assert(arrayBufferViewHasBuffer(array));
+}
+}