test: run code cache test by default and test generator

- Add the code cache tests to the default test suite, and test
  the bookkeeping when the binary is not built with the code cache.
- Test the code cache generator to make sure we do not accidentally
  break it - until we enable code cache in the CI.

Refs: https://github.com/nodejs/node/issues/21563
PR-URL: https://github.com/nodejs/node/pull/23855
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

2 files changed, 88 insertions, 16 deletions

diff --git a/test/code-cache/test-code-cache-generator.js b/test/code-cache/test-code-cache-generator.js
new file mode 100644
index 00000000000..972d89629c0
--- /dev/null
+++ b/test/code-cache/test-code-cache-generator.js
@@ -0,0 +1,58 @@
+'use strict';
+
+// This test verifies that the binary is compiled with code cache and the
+// cache is used when built in modules are compiled.
+
+const common = require('../common');
+
+const tmpdir = require('../common/tmpdir');
+const { spawnSync } = require('child_process');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+
+const generator = path.join(
+  __dirname, '..', '..', 'tools', 'generate_code_cache.js'
+);
+tmpdir.refresh();
+const dest = path.join(tmpdir.path, 'cache.cc');
+
+// Run tools/generate_code_cache.js
+const child = spawnSync(
+  process.execPath,
+  ['--expose-internals', generator, dest]
+);
+assert.ifError(child.error);
+if (child.status !== 0) {
+  console.log(child.stderr.toString());
+  assert.strictEqual(child.status, 0);
+}
+
+// Verifies that:
+// - node::DefineCodeCache()
+// - node::DefineCodeCacheHash()
+// are defined in the generated code.
+// See src/node_code_cache_stub.cc for explanations.
+
+const rl = readline.createInterface({
+  input: fs.createReadStream(dest),
+  crlfDelay: Infinity
+});
+
+let hasCacheDef = false;
+let hasHashDef = false;
+
+rl.on('line', common.mustCallAtLeast((line) => {
+  if (line.includes('DefineCodeCache(')) {
+    hasCacheDef = true;
+  }
+  if (line.includes('DefineCodeCacheHash(')) {
+    hasHashDef = true;
+  }
+}, 2));
+
+rl.on('close', common.mustCall(() => {
+  assert.ok(hasCacheDef);
+  assert.ok(hasHashDef);
+}));
diff --git a/test/code-cache/test-code-cache.js b/test/code-cache/test-code-cache.js
index b05e764e8ad..c1bfa80f434 100644
--- a/test/code-cache/test-code-cache.js
+++ b/test/code-cache/test-code-cache.js
@@ -1,8 +1,9 @@
 'use strict';
 
 // Flags: --expose-internals
-// This test verifies that the binary is compiled with code cache and the
-// cache is used when built in modules are compiled.
+// This test verifies that if the binary is compiled with code cache,
+// and the cache is used when built in modules are compiled.
+// Otherwise, verifies that no cache is used when compiling builtins.
 
 require('../common');
 const assert = require('assert');
@@ -18,23 +19,36 @@ const {
   compiledWithoutCache
 } = require('internal/bootstrap/cache');
 
-assert.strictEqual(
-  typeof process.config.variables.node_code_cache_path,
-  'string'
-);
-
-assert.deepStrictEqual(compiledWithoutCache, []);
-
 const loadedModules = process.moduleLoadList
   .filter((m) => m.startsWith('NativeModule'))
   .map((m) => m.replace('NativeModule ', ''));
 
-for (const key of loadedModules) {
-  assert(compiledWithCache.includes(key),
-         `"${key}" should've been compiled with code cache`);
-}
+// The binary is not configured with code cache, verifies that the builtins
+// are all compiled without cache and we are doing the bookkeeping right.
+if (process.config.variables.node_code_cache_path === undefined) {
+  assert.deepStrictEqual(compiledWithCache, []);
+  assert.notStrictEqual(compiledWithoutCache.length, 0);
+
+  for (const key of loadedModules) {
+    assert(compiledWithoutCache.includes(key),
+           `"${key}" should not have been compiled with code cache`);
+  }
 
-for (const key of cachableBuiltins) {
-  assert(isUint8Array(codeCache[key]) && codeCache[key].length > 0,
-         `Code cache for "${key}" should've been generated`);
+} else {
+  // The binary is configured with code cache.
+  assert.strictEqual(
+    typeof process.config.variables.node_code_cache_path,
+    'string'
+  );
+  assert.deepStrictEqual(compiledWithoutCache, []);
+
+  for (const key of loadedModules) {
+    assert(compiledWithCache.includes(key),
+           `"${key}" should've been compiled with code cache`);
+  }
+
+  for (const key of cachableBuiltins) {
+    assert(isUint8Array(codeCache[key]) && codeCache[key].length > 0,
+           `Code cache for "${key}" should've been generated`);
+  }
 }