Upload Kmake

test/benchmark/benchmark.status

@@ -0,0 +1,25 @@
+prefix benchmark
+
+# To mark a test as flaky, list the test name in the appropriate section
+# below, without ".js", followed by ": PASS,FLAKY". Example:
+# sample-test                       : PASS,FLAKY
+
+[true] # This section applies to all platforms
+
+# https://github.com/nodejs/node/issues/52690
+test-benchmark-crypto: PASS, FLAKY
+
+[$system==win32]
+
+[$system==linux]
+
+[$system==macos]
+
+[$system==solaris] # Also applies to SmartOS
+
+[$system==freebsd]
+
+[$system==aix]
+
+[$arch==arm]
+

test/benchmark/test-bechmark-readline.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('readline', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-assert.js

@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+
+// Minimal test for assert benchmarks. This makes sure the benchmarks aren't
+// completely broken but nothing more than that.
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('assert');

test/benchmark/test-benchmark-async-hooks.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for async_hooks benchmark test');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('async_hooks');

test/benchmark/test-benchmark-blob.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('blob', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-buffer.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('buffers', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-child-process.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('child_process', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-cluster.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('cluster');

test/benchmark/test-benchmark-crypto.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const { getFips } = require('crypto');
+
+if (getFips()) {
+  common.skip('some benchmarks are FIPS-incompatible');
+}
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('crypto', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-dgram.js

@@ -0,0 +1,10 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+// Dgram benchmarks use hardcoded ports. Thus, this test can not be run in
+// parallel with tests that choose random ports.
+
+runBenchmark('dgram');

test/benchmark/test-benchmark-dns.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('dns', { ...process.env, NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-domain.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('domain');

test/benchmark/test-benchmark-es.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('es', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-esm.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('esm', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-events.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('events', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-fs.js

@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+const runBenchmark = require('../common/benchmark');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+runBenchmark('fs', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-http.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for HTTP benchmark test');
+
+// Because the http benchmarks use hardcoded ports, this should be in sequential
+// rather than parallel to make sure it does not conflict with tests that choose
+// random available ports.
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('http', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-http2.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for HTTP/2 benchmark test');
+
+// Because the http benchmarks use hardcoded ports, this should be in sequential
+// rather than parallel to make sure it does not conflict with tests that choose
+// random available ports.
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('http2', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-mime.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('mime', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-misc.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('misc', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-module.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('module');

test/benchmark/test-benchmark-napi.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+
+if (common.isWindows) {
+  common.skip('vcbuild.bat doesn\'t build the n-api benchmarks yet');
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('addons are not supported in workers');
+}
+
+if (common.isDebug) {
+  common.skip('benchmark does not work with debug build yet');
+}
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('napi', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-net.js

@@ -0,0 +1,11 @@
+'use strict';
+
+require('../common');
+
+// Because the net benchmarks use hardcoded ports, this should be in sequential
+// rather than parallel to make sure it does not conflict with tests that choose
+// random available ports.
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('net', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-os.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('os');

test/benchmark/test-benchmark-path.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('path', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-process.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('process', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-querystring.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('querystring', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-streams.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('streams', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-string_decoder.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('string_decoder');

test/benchmark/test-benchmark-timers.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('timers', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-tls.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for TLS benchmark test');
+
+// Because the TLS benchmarks use hardcoded ports, this should be in sequential
+// rather than parallel to make sure it does not conflict with tests that choose
+// random available ports.
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('tls', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-url.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('url', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-util.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('util', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-v8.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('v8', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-validators.js

@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+
+// Minimal test for assert benchmarks. This makes sure the benchmarks aren't
+// completely broken but nothing more than that.
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('validators');

test/benchmark/test-benchmark-vm.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('vm', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-websocket.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const common = require('../common');
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for Websocket benchmark test');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('websocket', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-webstreams.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('webstreams', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-worker.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.enoughTestMem)
+  common.skip('Insufficient memory for Worker benchmark test');
+
+// Because the worker benchmarks can run on different threads,
+// this should be in sequential rather than parallel to make sure
+// it does not conflict with tests that choose random available ports.
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('worker', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/test-benchmark-zlib.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('zlib', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });

test/benchmark/testcfg.py

@@ -0,0 +1,6 @@
+import sys, os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+import testpy
+
+def GetConfiguration(context, root):
+  return testpy.SimpleTestConfiguration(context, root, 'benchmark')