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, 23 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 521203
Default Alt Text: v8.js (5 KB)

Event Timeline