handle multi-line test names (#1234)

escape newline for both jest runs and debugging.

resolve #1204

Author: connectdotz

src/helpers.ts

@@ -126,21 +126,37 @@ export const getDefaultJestCommand = (rootPath = ''): string | undefined => {
 
 /**
  * Escapes special characters in a string to be used as a regular expression pattern.
- * @param str - The string to escape.
- * @returns The escaped string.
+ * If the provided value is already a regex (indicated by `isRegExp`), it is returned unmodified.
  *
- * Note: the conversion algorithm is taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+ * [2025.04.14] Additionally, the function can replace actual newline characters with the literal sequence `\n`.
+ * This behavior is enabled by default (via `replaceNewLine = true`) to ensure that
+ * the regex pattern can be safely passed as a single command line argument—for example,
+ * for options like "--testPathPattern" or "testNamePattern". Even for regex usage, modifying
+ * newlines in this way can help prevent issues with multi-line arguments that might otherwise
+ * break in shell contexts.
+ *
+ * @param {string | StringPattern} str - The string or object to escape. When an object is provided,
+ *   it must have a `value` property containing the string, and can optionally include:
+ *   - `isRegExp`: if true, the function assumes the string is already a valid regex and returns it as-is.
+ *   - `exactMatch`: if true, the resulting escaped string is anchored with '^' at the start and '$' at the end.
+ * @param {boolean} [replaceNewLine=true] - Whether to replace newline characters with the literal
+ *   sequence "\n". This is beneficial when the result is used as a command line argument, even though
+ *   it alters the actual newline characters that might be expected in some regex patterns.
+ *
+ * @returns {string} The escaped string, suitable for use as a regex pattern and for passing as a shell argument.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
  */
-export function escapeRegExp(str: string | StringPattern): string {
+export function escapeRegExp(str: string | StringPattern, replaceNewLine = true): string {
   const sp: StringPattern = typeof str === 'string' ? { value: str } : str;
+  let value: string;
   if (sp.isRegExp) {
-    return sp.value;
-  }
-  const escaped = sp.value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-  if (sp.exactMatch) {
-    return escaped + '$';
+    value = sp.value;
+  } else {
+    const escaped = sp.value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+    value = sp.exactMatch ? escaped + '$' : escaped;
   }
-  return escaped;
+  return replaceNewLine ? value.replace(/\r\n|\r|\n/g, '\\n') : value;
 }
 
 /**

src/test-provider/test-item-data.ts

@@ -798,10 +798,7 @@ export class TestData extends TestResultData {
   }
 
   private getTestNamePattern(): TestNamePattern {
-    if (isDataNode(this.node)) {
-      return { value: this.node.fullName, exactMatch: true };
-    }
-    return { value: this.node.fullName, exactMatch: false };
+    return { value: this.node.fullName, exactMatch: isDataNode(this.node) || false };
   }
 
   getJestRunRequest(options?: ScheduleTestOptions): JestExtRequestType {

tests/helpers.test.ts

@@ -148,18 +148,26 @@ describe('ModuleHelpers', () => {
 
 describe('escapeRegExp', () => {
   it.each`
-    str                                        | expected
-    ${'no special char'}                       | ${'no special char'}
-    ${'with (a)'}                              | ${'with \\(a\\)'}
-    ${'with {} and $sign'}                     | ${'with \\{\\} and \\$sign'}
-    ${'with []'}                               | ${'with \\[\\]'}
-    ${{ value: 'with []', exactMatch: true }}  | ${'with \\[\\]$'}
-    ${{ value: 'with []', exactMatch: false }} | ${'with \\[\\]'}
-    ${{ value: 'with []', isRegExp: true }}    | ${'with []'}
-    ${{ value: 'with []', isRegExp: false }}   | ${'with \\[\\]'}
+    case  | str                                            | expected
+    ${1}  | ${'no special char'}                           | ${'no special char'}
+    ${2}  | ${'with (a)'}                                  | ${'with \\(a\\)'}
+    ${3}  | ${'with {} and $sign'}                         | ${'with \\{\\} and \\$sign'}
+    ${4}  | ${'with []'}                                   | ${'with \\[\\]'}
+    ${5}  | ${{ value: 'with []', exactMatch: true }}      | ${'with \\[\\]$'}
+    ${6}  | ${{ value: 'with []', exactMatch: false }}     | ${'with \\[\\]'}
+    ${7}  | ${{ value: 'with []', isRegExp: true }}        | ${'with []'}
+    ${8}  | ${{ value: 'with []', isRegExp: false }}       | ${'with \\[\\]'}
+    ${9}  | ${'with\nnewline'}                             | ${'with\\nnewline'}
+    ${10} | ${'with\r\nnewline'}                           | ${'with\\nnewline'}
+    ${11} | ${{ value: 'with\nnewline', isRegExp: false }} | ${'with\\nnewline'}
+    ${12} | ${{ value: 'with\nnewline', isRegExp: true }}  | ${'with\\nnewline'}
   `('escapeRegExp: $str', ({ str, expected }) => {
     expect(escapeRegExp(str)).toEqual(expected);
   });
+  it('can skip newline handling', () => {
+    expect(escapeRegExp('with\nnewline', true)).toEqual('with\\nnewline');
+    expect(escapeRegExp('with\nnewline', false)).toEqual('with\nnewline');
+  });
 });
 describe('testIdString', () => {
   it.each`