Page MenuHomePhorge
Files F3058655

v8.js
No OneTemporary
Actions

Size
5 KB
Referenced Files
None
Subscribers
None

v8.js
View Options

import { test, testDeep, summary } from './helpers.js';
import v8 from 'node:v8';
console.log('startupSnapshot\n');
test('isBuildingSnapshot is a function', typeof v8.startupSnapshot.isBuildingSnapshot, 'function');
test('isBuildingSnapshot returns false', v8.startupSnapshot.isBuildingSnapshot(), false);
test('addSerializeCallback is a function', typeof v8.startupSnapshot.addSerializeCallback, 'function');
test('addDeserializeCallback is a function', typeof v8.startupSnapshot.addDeserializeCallback, 'function');
test('addSerializeCallback returns undefined', v8.startupSnapshot.addSerializeCallback(() => {}), undefined);
test('addDeserializeCallback returns undefined', v8.startupSnapshot.addDeserializeCallback(() => {}), undefined);
console.log('\ncachedDataVersionTag\n');
test('cachedDataVersionTag is a function', typeof v8.cachedDataVersionTag, 'function');
const tag = v8.cachedDataVersionTag();
test('cachedDataVersionTag returns a number', typeof tag, 'number');
test('cachedDataVersionTag is non-zero', tag !== 0, true);
test('cachedDataVersionTag is stable', v8.cachedDataVersionTag() === v8.cachedDataVersionTag(), true);
console.log('\ngetHeapStatistics\n');
const stats = v8.getHeapStatistics();
test('getHeapStatistics returns object', typeof stats, 'object');
const heapFields = [
'total_heap_size', 'total_heap_size_executable', 'total_physical_size',
'total_available_size', 'total_global_handles_size', 'used_global_handles_size',
'used_heap_size', 'heap_size_limit', 'malloced_memory',
'peak_malloced_memory', 'does_zap_garbage', 'number_of_native_contexts',
'number_of_detached_contexts', 'total_heap_blinded_size'
];
for (const field of heapFields) {
test(`getHeapStatistics has ${field}`, typeof stats[field], 'number');
}
test('used_heap_size > 0', stats.used_heap_size > 0, true);
test('total_heap_size >= used_heap_size', stats.total_heap_size >= stats.used_heap_size, true);
test('total_physical_size > 0', stats.total_physical_size > 0, true);
test('heap_size_limit > 0', stats.heap_size_limit > 0, true);
test('number_of_native_contexts >= 1', stats.number_of_native_contexts >= 1, true);
console.log('\ngetHeapSpaceStatistics\n');
const spaces = v8.getHeapSpaceStatistics();
test('getHeapSpaceStatistics returns array', Array.isArray(spaces), true);
test('getHeapSpaceStatistics has spaces', spaces.length >= 1, true);
const spaceFields = ['space_name', 'space_size', 'space_used_size', 'space_available_size', 'physical_space_size'];
for (const space of spaces) {
test(`space has name`, typeof space.space_name, 'string');
for (const field of spaceFields) {
test(`${space.space_name} has ${field}`, typeof space[field], field === 'space_name' ? 'string' : 'number');
}
}
console.log('\ngetHeapCodeStatistics\n');
const code = v8.getHeapCodeStatistics();
test('getHeapCodeStatistics returns object', typeof code, 'object');
test('has code_and_metadata_size', typeof code.code_and_metadata_size, 'number');
test('has bytecode_and_metadata_size', typeof code.bytecode_and_metadata_size, 'number');
test('has external_script_source_size', typeof code.external_script_source_size, 'number');
test('has cpu_profiler_metadata_size', typeof code.cpu_profiler_metadata_size, 'number');
test('code_and_metadata_size >= bytecode_and_metadata_size', code.code_and_metadata_size >= code.bytecode_and_metadata_size, true);
test('external_script_source_size > 0', code.external_script_source_size > 0, true);
console.log('\nserialize / deserialize\n');
const roundtrip = (label, value) => {
const buf = v8.serialize(value);
test(`${label}: serialize returns Uint8Array`, buf instanceof Uint8Array, true);
test(`${label}: buffer is non-empty`, buf.length > 0, true);
const out = v8.deserialize(buf);
test(`${label}: round-trip typeof`, typeof out, typeof value);
return out;
};
roundtrip('undefined', undefined);
roundtrip('null', null);
roundtrip('true', true);
roundtrip('false', false);
const n = roundtrip('integer', 42);
test('integer value preserved', n, 42);
const f = roundtrip('float', 3.14);
test('float value preserved', Math.abs(f - 3.14) < 1e-10, true);
const buf = v8.serialize(NaN);
const nan = v8.deserialize(buf);
test('NaN round-trips', Number.isNaN(nan), true);
const s = roundtrip('string', 'hello world');
test('string value preserved', s, 'hello world');
const empty = roundtrip('empty string', '');
test('empty string preserved', empty, '');
const arr = v8.deserialize(v8.serialize([1, 2, 3]));
test('array round-trips', Array.isArray(arr), true);
test('array length preserved', arr.length, 3);
test('array[0]', arr[0], 1);
test('array[2]', arr[2], 3);
const obj = v8.deserialize(v8.serialize({ x: 1, y: 'two', z: true }));
test('object round-trips', typeof obj, 'object');
test('object.x', obj.x, 1);
test('object.y', obj.y, 'two');
test('object.z', obj.z, true);
const nested = v8.deserialize(v8.serialize({ a: [1, { b: 2 }], c: null }));
test('nested object.a is array', Array.isArray(nested.a), true);
test('nested object.a[1].b', nested.a[1].b, 2);
test('nested object.c is null', nested.c, null);
let threw = false;
try { v8.deserialize(new Uint8Array([0x00, 0x00])); } catch (e) { threw = true; }
test('deserialize rejects bad magic', threw, true);
console.log('\nno-op methods\n');
test('setFlagsFromString is a function', typeof v8.setFlagsFromString, 'function');
test('setFlagsFromString returns undefined', v8.setFlagsFromString('--harmony'), undefined);
test('stopCoverage is a function', typeof v8.stopCoverage, 'function');
test('stopCoverage returns undefined', v8.stopCoverage(), undefined);
test('takeCoverage is a function', typeof v8.takeCoverage, 'function');
test('takeCoverage returns undefined', v8.takeCoverage(), undefined);
console.log('\nconstants\n');
test('constants is an object', typeof v8.constants, 'object');
summary();

File Metadata

Mime Type
application/javascript
Expires
Fri, Apr 3, 6:26 PM (1 d, 19 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
521203
Default Alt Text
v8.js (5 KB)

Event Timeline