Upload Kmake

test/message/assert_throws_stack.js

@@ -0,0 +1,6 @@
+'use strict';
+
+require('../common');
+const assert = require('assert').strict;
+
+assert.throws(() => { throw new Error('foo'); }, { bar: true });

test/message/assert_throws_stack.out

@@ -0,0 +1,38 @@
+node:assert:*
+      throw err;
+      ^
+
+AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
++ actual - expected
+
++ Comparison {}
+- Comparison {
+-   bar: true
+- }
+    at Object.<anonymous> (*assert_throws_stack.js:*:*)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  generatedMessage: true,
+  code: 'ERR_ASSERTION',
+  actual: Error: foo
+      at assert.throws.bar (*assert_throws_stack.js:*)
+      at getActual (node:assert:*)
+      at strict.throws (node:assert:*)
+      at Object.<anonymous> (*assert_throws_stack.js:*:*)
+      at *
+      at *
+      at *
+      at *
+      at *
+      at *,
+  expected: { bar: true },
+  operator: 'throws'
+}
+
+Node.js *

test/message/console_assert.js

@@ -0,0 +1,5 @@
+'use strict';
+
+require('../common');
+
+console.assert(false, Symbol('hello'));

test/message/console_assert.out

@@ -0,0 +1 @@
+Assertion failed* Symbol(hello)

test/message/internal_assert.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// Flags: --expose-internals
+require('../common');
+
+const assert = require('internal/assert');
+assert(false);

test/message/internal_assert.out

@@ -0,0 +1,21 @@
+node:internal/assert:*
+    throw new ERR_INTERNAL_ASSERTION(message);
+    ^
+
+Error [ERR_INTERNAL_ASSERTION]: This is caused by either a bug in Node.js or incorrect usage of Node.js internals.
+Please open an issue with this stack trace at https://github.com/nodejs/node/issues
+
+    at assert (node:internal/assert:*:*)
+    at * (*test*message*internal_assert.js:7:1)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  code: 'ERR_INTERNAL_ASSERTION'
+}
+
+Node.js *

test/message/internal_assert_fail.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// Flags: --expose-internals
+require('../common');
+
+const assert = require('internal/assert');
+assert.fail('Unreachable!');

test/message/internal_assert_fail.out

@@ -0,0 +1,22 @@
+node:internal/assert:*
+  throw new ERR_INTERNAL_ASSERTION(message);
+  ^
+
+Error [ERR_INTERNAL_ASSERTION]: Unreachable!
+This is caused by either a bug in Node.js or incorrect usage of Node.js internals.
+Please open an issue with this stack trace at https://github.com/nodejs/node/issues
+
+    at assert.fail (node:internal/assert:*:*)
+    at * (*test*message*internal_assert_fail.js:7:8)
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  code: 'ERR_INTERNAL_ASSERTION'
+}
+
+Node.js *

test/message/max_tick_depth.js

@@ -0,0 +1,31 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+process.maxTickDepth = 10;
+let i = 20;
+process.nextTick(function f() {
+  console.error(`tick ${i}`);
+  if (i-- > 0)
+    process.nextTick(f);
+});

test/message/max_tick_depth.out

@@ -0,0 +1,21 @@
+tick 20
+tick 19
+tick 18
+tick 17
+tick 16
+tick 15
+tick 14
+tick 13
+tick 12
+tick 11
+tick 10
+tick 9
+tick 8
+tick 7
+tick 6
+tick 5
+tick 4
+tick 3
+tick 2
+tick 1
+tick 0

test/message/message.status

@@ -0,0 +1,19 @@
+prefix message
+
+# 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
+
+[$system==win32]
+
+[$system==linux]
+
+[$system==macos]
+
+[$system==solaris] # Also applies to SmartOS
+
+[$system==freebsd]
+
+[$system==aix]

test/message/nexttick_throw.js

@@ -0,0 +1,34 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+require('../common');
+
+process.nextTick(function() {
+  process.nextTick(function() {
+    process.nextTick(function() {
+      process.nextTick(function() {
+        // eslint-disable-next-line no-undef,no-unused-expressions
+        undefined_reference_error_maker;
+      });
+    });
+  });
+});

test/message/nexttick_throw.out

@@ -0,0 +1,9 @@
+
+*test*message*nexttick_throw.js:*
+        undefined_reference_error_maker;
+        ^
+ReferenceError: undefined_reference_error_maker is not defined
+    at *test*message*nexttick_throw.js:*:*
+    at process.processTicksAndRejections (node:internal/process/task_queues:*:*)
+
+Node.js *

test/message/node_run_non_existent.js

@@ -0,0 +1,14 @@
+'use strict';
+
+require('../common');
+const assert = require('node:assert').strict;
+const childProcess = require('node:child_process');
+const fixtures = require('../common/fixtures');
+
+const child = childProcess.spawnSync(
+  process.execPath,
+  [ '--no-warnings', '--run', 'non-existent-command'],
+  { cwd: fixtures.path('run-script'), encoding: 'utf8' },
+);
+assert.strictEqual(child.status, 1);
+console.log(child.stderr);

test/message/node_run_non_existent.out

@@ -0,0 +1,16 @@
+Missing script: "non-existent-command" for *
+
+Available scripts are:
+  test: echo "Error: no test specified" && exit 1
+  ada: ada
+  ada-windows: ada.bat
+  positional-args: positional-args
+  positional-args-windows: positional-args.bat
+  custom-env: custom-env
+  custom-env-windows: custom-env.bat
+  path-env: path-env
+  path-env-windows: path-env.bat
+  special-env-variables: special-env-variables
+  special-env-variables-windows: special-env-variables.bat
+  pwd: pwd
+  pwd-windows: cd

test/message/test-testpy-env-var-via-comment.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// Env: A_SET_ENV_VAR=A_SET_ENV_VAR_VALUE B_SET_ENV_VAR=B_SET_ENV_VAR_VALUE
+// Flags: --test-isolation=none --expose-internals
+
+require('../common');
+const assert = require('node:assert');
+
+// This test verifies that the Python test runner can set environment variables
+// via comments in the test file, similar to how we set flags via comments.
+// Ref: https://github.com/nodejs/node/issues/58179
+assert.strictEqual(process.env.A_SET_ENV_VAR, 'A_SET_ENV_VAR_VALUE');
+assert.strictEqual(process.env.B_SET_ENV_VAR, 'B_SET_ENV_VAR_VALUE');
+// Check interop with flags
+const flag = require('internal/options').getOptionValue('--test-isolation');
+assert.strictEqual(flag, 'none');

test/message/testcfg.py

@@ -0,0 +1,153 @@
+from __future__ import print_function
+# Copyright 2008 the V8 project authors. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#     * Neither the name of Google Inc. nor the names of its
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import test
+import os
+from os.path import join, exists, basename, isdir
+import re
+from functools import reduce
+
+FLAGS_PATTERN = re.compile(r"//\s+Flags:(.*)")
+ENV_PATTERN = re.compile(r"//\s+Env:(.*)")
+
+class MessageTestCase(test.TestCase):
+
+  def __init__(self, path, file, expected, arch, mode, context, config):
+    super(MessageTestCase, self).__init__(context, path, arch, mode)
+    self.file = file
+    self.expected = expected
+    self.config = config
+    self.arch = arch
+    self.mode = mode
+    self.parallel = True
+
+  def IgnoreLine(self, str):
+    """Ignore empty lines and valgrind output."""
+    if not str.strip(): return True
+    else: return str.startswith('==') or str.startswith('**')
+
+  def IsFailureOutput(self, output):
+    f = open(self.expected)
+    # Skip initial '#' comment and spaces
+    #for line in f:
+    #  if (not line.startswith('#')) and (not line.strip()):
+    #    break
+    # Convert output lines to regexps that we can match
+    env = { 'basename': basename(self.file) }
+    patterns = [ ]
+    for line in f:
+      if not line.strip():
+        continue
+      pattern = re.escape(line.rstrip() % env)
+      pattern = pattern.replace('\\*', '.*')
+      pattern = '^%s$' % pattern
+      patterns.append(pattern)
+    # Compare actual output with the expected
+    raw_lines = (output.stdout + output.stderr).split('\n')
+    outlines = [ s for s in raw_lines if not self.IgnoreLine(s) ]
+    if len(outlines) != len(patterns):
+      print("length differs.")
+      print("expect=%d" % len(patterns))
+      print("actual=%d" % len(outlines))
+      print("patterns:")
+      for i in range(len(patterns)):
+        print("pattern = %s" % patterns[i])
+      print("outlines:")
+      for i in range(len(outlines)):
+        print("outline = %s" % outlines[i])
+      return True
+    for i in range(len(patterns)):
+      if not re.match(patterns[i], outlines[i]):
+        print("match failed")
+        print("line=%d" % i)
+        print("expect=%s" % patterns[i])
+        print("actual=%s" % outlines[i])
+        return True
+    return False
+
+  def _parse_source_env(self, source):
+    env_match = ENV_PATTERN.search(source)
+    env = {}
+    if env_match:
+      for env_pair in env_match.group(1).strip().split():
+        var, value = env_pair.split('=')
+        env[var] = value
+    return env
+
+  def GetLabel(self):
+    return "%s %s" % (self.mode, self.GetName())
+
+  def GetName(self):
+    return self.path[-1]
+
+  def GetRunConfiguration(self):
+    result = [self.config.context.GetVm(self.arch, self.mode)]
+    source = open(self.file).read()
+    flags_match = FLAGS_PATTERN.search(source)
+    envs = self._parse_source_env(source)
+    if flags_match:
+      result += flags_match.group(1).strip().split()
+    result.append(self.file)
+    return {
+        'command': result,
+        'envs': envs
+    }
+
+  def GetSource(self):
+    return (open(self.file).read()
+          + "\n--- expected output ---\n"
+          + open(self.expected).read())
+
+
+class MessageTestConfiguration(test.TestConfiguration):
+  def Ls(self, path):
+    if isdir(path):
+      return [f for f in os.listdir(path)
+              if f.endswith('.js') or f.endswith('.mjs')]
+    else:
+      return []
+
+  def ListTests(self, current_path, path, arch, mode):
+    all_tests = [current_path + [t] for t in self.Ls(self.root)]
+    result = []
+    for tst in all_tests:
+      if self.Contains(path, tst):
+        file_path = join(self.root, reduce(join, tst[1:], ''))
+        output_path = file_path[:file_path.rfind('.')] + '.out'
+        if not exists(output_path):
+          raise Exception("Could not find %s" % output_path)
+        result.append(MessageTestCase(tst, file_path, output_path,
+                                      arch, mode, self.context, self))
+    return result
+
+  def GetBuildRequirements(self):
+    return ['sample', 'sample=shell']
+
+
+def GetConfiguration(context, root):
+  return MessageTestConfiguration(context, root, 'message')

test/message/util-inspect-error-cause.js

@@ -0,0 +1,54 @@
+'use strict';
+
+require('../common');
+
+const { inspect } = require('util');
+
+class FoobarError extends Error {
+  status = 'Feeling good';
+}
+
+const cause1 = new TypeError('Inner error');
+const cause2 = new FoobarError('Individual message', { cause: cause1 });
+cause2.extraProperties = 'Yes!';
+const cause3 = new Error('Stack causes', { cause: cause2 });
+
+const cause4 = new Error('Number error cause', { cause: 42 });
+const cause5 = new Error('Object cause', {
+  cause: {
+    message: 'Unique',
+    name: 'Error',
+    stack: 'Error: Unique\n' +
+           '    at Module._compile (node:internal/modules/cjs/loader:827:30)',
+  },
+});
+const cause6 = new Error('undefined cause', {
+  cause: undefined,
+});
+
+console.log(cause4);
+console.log(cause5);
+console.log(cause6);
+
+process.nextTick(() => {
+  const error = new RangeError('New Stack Frames', { cause: cause2 });
+  const error2 = new RangeError('New Stack Frames', { cause: cause3 });
+
+  inspect.defaultOptions.colors = true;
+
+  console.log(inspect(error));
+  console.log(inspect(cause3));
+  console.log(inspect(error2));
+
+  inspect.defaultOptions.colors = false;
+
+  console.log(inspect(error));
+  console.log(inspect(cause3));
+  console.log(inspect(error2));
+});
+
+{
+  const error = new Error('cause that throws');
+  Reflect.defineProperty(error, 'cause', { get() { throw new Error(); } });
+  console.log(inspect(error));
+}

test/message/util-inspect-error-cause.out

@@ -0,0 +1,201 @@
+Error: Number error cause
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  [cause]: 42
+}
+Error: Object cause
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  [cause]: {
+    message: 'Unique',
+    name: 'Error',
+    stack: 'Error: Unique\n' +
+      '    at Module._compile (node:internal/modules/cjs/loader:827:30)'
+  }
+}
+Error: undefined cause
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  [cause]: undefined
+}
+Error: cause that throws
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at * {
+  [cause]: [Getter]
+}
+RangeError: New Stack Frames
+    at *
+*[90m    at *[39m {
+  [cause]: FoobarError: Individual message
+      at *
+  *[90m    at *[39m
+  *[90m    ... 6 lines matching cause stack trace ...*[39m
+  *[90m    at *[39m {
+    status: *[32m'Feeling good'*[39m,
+    extraProperties: *[32m'Yes!'*[39m,
+    [cause]: TypeError: Inner error
+        at *
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+  }
+}
+Error: Stack causes
+    at *
+*[90m    at *[39m
+*[90m    ... 6 lines matching cause stack trace ...*[39m
+*[90m    at *[39m {
+  [cause]: FoobarError: Individual message
+      at *
+  *[90m    at *[39m
+  *[90m    ... 6 lines matching cause stack trace ...*[39m
+  *[90m    at *[39m {
+    status: *[32m'Feeling good'*[39m,
+    extraProperties: *[32m'Yes!'*[39m,
+    [cause]: TypeError: Inner error
+        at *
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+    *[90m    at *[39m
+  }
+}
+RangeError: New Stack Frames
+    at *
+*[90m    at *[39m {
+  [cause]: Error: Stack causes
+      at *
+  *[90m    at *[39m
+  *[90m    ... 6 lines matching cause stack trace ...*[39m
+  *[90m    at *[39m {
+    [cause]: FoobarError: Individual message
+        at *
+    *[90m    at *[39m
+    *[90m    ... 6 lines matching cause stack trace ...*[39m
+    *[90m    at *[39m {
+      status: *[32m'Feeling good'*[39m,
+      extraProperties: *[32m'Yes!'*[39m,
+      [cause]: TypeError: Inner error
+          at *
+      *[90m    at *[39m
+      *[90m    at *[39m
+      *[90m    at *[39m
+      *[90m    at *[39m
+      *[90m    at *[39m
+      *[90m    at *[39m
+      *[90m    at *[39m
+      *[90m    at *[39m
+    }
+  }
+}
+RangeError: New Stack Frames
+    at *
+    at * {
+  [cause]: FoobarError: Individual message
+      at *
+      at *
+      ... 6 lines matching cause stack trace ...
+      at * {
+    status: 'Feeling good',
+    extraProperties: 'Yes!',
+    [cause]: TypeError: Inner error
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+  }
+}
+Error: Stack causes
+    at *
+    at *
+    ... 6 lines matching cause stack trace ...
+    at * {
+  [cause]: FoobarError: Individual message
+      at *
+      at *
+      ... 6 lines matching cause stack trace ...
+      at *
+    status: 'Feeling good',
+    extraProperties: 'Yes!',
+    [cause]: TypeError: Inner error
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+  }
+}
+RangeError: New Stack Frames
+    at *
+    at * {
+  [cause]: Error: Stack causes
+      at *
+      at *
+      ... 6 lines matching cause stack trace ...
+      at * {
+    [cause]: FoobarError: Individual message
+        at *
+        at *
+        ... 6 lines matching cause stack trace ...
+        at * {
+      status: 'Feeling good',
+      extraProperties: 'Yes!',
+      [cause]: TypeError: Inner error
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+    }
+  }
+}

test/message/util_inspect_error.js

@@ -0,0 +1,12 @@
+'use strict';
+
+require('../common');
+const util = require('util');
+
+const err = new Error('foo\nbar');
+
+console.log(util.inspect({ err, nested: { err } }, { compact: true }));
+console.log(util.inspect({ err, nested: { err } }, { compact: false }));
+
+err.foo = 'bar';
+console.log(util.inspect(err, { compact: true, breakLength: 5 }));

test/message/util_inspect_error.out

@@ -0,0 +1,63 @@
+{ err:
+   Error: foo
+   bar
+       at *util_inspect_error*
+       at *
+       at *
+       at *
+       at *
+       at *
+       at *
+       at *
+       at *
+  nested:
+   { err:
+      Error: foo
+      bar
+          at *util_inspect_error*
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+          at *
+{
+  err: Error: foo
+  bar
+      at *util_inspect_error*
+      at *
+      at *
+      at *
+      at *
+      at *
+      at *
+      at *
+      at *
+  nested: {
+    err: Error: foo
+    bar
+        at *util_inspect_error*
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+        at *
+  }
+}
+{ Error: foo
+bar
+    at *util_inspect_error*
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+    at *
+  foo: 'bar' }