Diffusion Ant (mir/inline-method) Code

ant/examples/spec/v8.js
3fa05edd2fe3mir/inline-method

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();

Owner Packages

No Owners