单元测试覆盖

package text;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * Unit tests for TextUtils.truncateWithEllipsis using JUnit Jupiter.
 * Covers: null handling, invalid maxChars, no-truncation paths, wordBoundary behavior,
 * and trimming of trailing whitespace across different whitespace characters and Unicode.
 */
public class TextUtilsTest {

    // === Boundary & Exception Handling ===

    // Null input should return null, regardless of wordBoundary flag.
    @Test
    void nullInputReturnsNull() {
        assertNull(TextUtils.truncateWithEllipsis(null, 5, false));
        assertNull(TextUtils.truncateWithEllipsis(null, 5, true));
    }

    // maxChars < 1 should throw IllegalArgumentException.
    @Test
    void maxCharsLessThanOneThrows() {
        assertThrows(IllegalArgumentException.class,
                () -> TextUtils.truncateWithEllipsis("abc", 0, false));
        assertThrows(IllegalArgumentException.class,
                () -> TextUtils.truncateWithEllipsis("abc", -1, true));
    }

    // === No Truncation Paths (text length <= maxChars) ===

    // Returns original text unchanged when length <= maxChars.
    @Test
    void returnsOriginalWhenLengthEqualOrLess() {
        assertEquals("Hello", TextUtils.truncateWithEllipsis("Hello", 5, true));
        assertEquals("短句", TextUtils.truncateWithEllipsis("短句", 10, true));
        // Trailing spaces should be preserved when not truncated.
        assertEquals("Hi  ", TextUtils.truncateWithEllipsis("Hi  ", 10, false));
        // Only spaces, not truncated.
        assertEquals("   ", TextUtils.truncateWithEllipsis("   ", 5, true));
    }

    // === Truncation without wordBoundary ===

    // Exact cut at maxChars and append ellipsis.
    @Test
    void truncateWithoutWordBoundaryExactCut() {
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello world", 5, false));
        assertEquals("ab...", TextUtils.truncateWithEllipsis("abc", 2, false));
        assertEquals("短句...", TextUtils.truncateWithEllipsis("短句测试", 2, false));
    }

    // Trailing spaces at the cut are removed before ellipsis.
    @Test
    void truncateWithoutWordBoundaryTrailingSpacesTrimmed() {
        // Cut yields trailing space, which should be trimmed.
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello world", 6, false));
        // Multiple spaces trimmed.
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello   world", 8, false));
        // Tab at the cut should be trimmed.
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello\tworld", 6, false));
        // Newline at the cut should be trimmed.
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello\nworld", 6, false));
        // If the cut is a space-only segment, trimmed to empty then ellipsis.
        assertEquals("...", TextUtils.truncateWithEllipsis(" a", 1, false));
        assertEquals("...", TextUtils.truncateWithEllipsis("   b", 2, false));
    }

    // === Truncation with wordBoundary ===

    // Cut at last whitespace within limit; whitespace itself is excluded from substring.
    @Test
    void wordBoundaryCutsAtLastWhitespaceWithinLimit() {
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello world", 7, true));
        assertEquals("Hello world...", TextUtils.truncateWithEllipsis("Hello world again", 12, true));
        // Multiple spaces: should still cut before the last space within limit and trim remaining trailing spaces.
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello   world", 8, true));
    }

    // Whitespace exactly at index 0 should not be used as a cut point (idx > 0 requirement).
    @Test
    void wordBoundaryDoesNotCutWhenWhitespaceIndexIsZero() {
        assertEquals("...", TextUtils.truncateWithEllipsis(" hello", 1, true)); // cut=1, substring is " ", trimmed to empty
    }

    // No whitespace within or at the cut window -> fall back to hard cut at maxChars.
    @Test
    void wordBoundaryFallsBackWhenNoWhitespaceWithinLimit() {
        assertEquals("Super...", TextUtils.truncateWithEllipsis("Supercalifragilistic", 5, true));
    }

    // Whitespace exactly at position == maxChars is ignored by lastWhitespaceBefore (since it scans up to limit-1).
    @Test
    void wordBoundaryIgnoresWhitespaceExactlyAtLimit() {
        // "HelloWorld" (10 chars) then a space at index 10; limit=10, space at limit is ignored.
        assertEquals("HelloWorld...", TextUtils.truncateWithEllipsis("HelloWorld test", 10, true));
    }

    // === Mixed whitespace trimming checks ===

    // Space at cut: trimmed
    @Test
    void trimsSpaceAtCut() {
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello world", 6, true));
    }

    // Newline and tab at cut: trimmed
    @Test
    void trimsNewlineAndTabAtCut() {
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello\nworld", 6, true));
        assertEquals("Hello...", TextUtils.truncateWithEllipsis("Hello\tworld", 6, true));
    }
}

'use strict';
const assert = require('assert');

/**
 * Function under test
 */
/**
 * Simple template rendering: replaces {{key}} with values from data.
 * Features:
 * - Supports default values: {{key|default text}}.
 * - If options.strict is true, throws if a placeholder has no provided value.
 * - Non-string values are coerced with String().
 * - tpl must be a string; throws TypeError otherwise.
 */
function renderTemplate(tpl, data, options) {
  if (typeof tpl !== 'string') {
    throw new TypeError('tpl must be a string');
  }
  const opts = Object.assign({ strict: false }, options || {});
  const ctx = data || {};
  return tpl.replace(/{{\s*([a-zA-Z0-9_.-]+)(?:\|([^}]+))?\s*}}/g, (m, key, def) => {
    const val = getByPath(ctx, key);
    if (val == null) {
      if (opts.strict && def == null) {
        throw new Error('Missing value for ' + key);
      }
      return def != null ? String(def) : (opts.strict ? '' : m);
    }
    return String(val);
  });
}

function getByPath(obj, path) {
  const parts = path.split('.');
  let cur = obj;
  for (const p of parts) {
    if (cur == null || typeof cur !== 'object' || !(p in cur)) {
      return undefined;
    }
    cur = cur[p];
  }
  return cur;
}

describe('renderTemplate', () => {
  // Type enforcement: tpl must be a string
  describe('type checks', () => {
    it('throws TypeError when tpl is not a string', () => {
      const invalids = [null, undefined, 123, {}, [], () => {}];
      for (const v of invalids) {
        assert.throws(() => renderTemplate(v, {}), TypeError);
      }
    });

    it('returns tpl unchanged when there are no placeholders', () => {
      const s = 'Hello world';
      assert.strictEqual(renderTemplate(s, {}), s);
    });
  });

  // Core replacement logic
  describe('basic replacement', () => {
    it('replaces a single placeholder with provided value', () => {
      const out = renderTemplate('Hello {{name}}', { name: 'Ada' });
      assert.strictEqual(out, 'Hello Ada');
    });

    it('replaces multiple occurrences of the same key', () => {
      const out = renderTemplate('X {{name}} {{name}} Y', { name: 'Bob' });
      assert.strictEqual(out, 'X Bob Bob Y');
    });

    it('supports whitespace around key inside placeholder', () => {
      const out = renderTemplate('Hi {{   user.name   }}!', { user: { name: 'Ada' } });
      assert.strictEqual(out, 'Hi Ada!');
    });
  });

  // Non-string value coercion
  describe('value coercion with String()', () => {
    it('coerces numbers', () => {
      const out = renderTemplate('Value: {{n}}', { n: 42 });
      assert.strictEqual(out, 'Value: 42');
    });

    it('coerces booleans', () => {
      const outTrue = renderTemplate('Flag: {{f}}', { f: true });
      const outFalse = renderTemplate('Flag: {{f}}', { f: false });
      assert.strictEqual(outTrue, 'Flag: true');
      assert.strictEqual(outFalse, 'Flag: false');
    });

    it('coerces objects', () => {
      const out = renderTemplate('Obj: {{o}}', { o: { a: 1 } });
      assert.strictEqual(out, 'Obj: [object Object]');
    });

    it('coerces Date via String()', () => {
      const d = new Date('2020-01-01T00:00:00Z');
      const out = renderTemplate('Date: {{d}}', { d });
      assert.strictEqual(out, `Date: ${String(d)}`);
    });
  });

  // Default values behavior
  describe('default values', () => {
    it('uses default when key is missing and strict is false (default)', () => {
      const out = renderTemplate('Hello {{name|friend}}', {});
      assert.strictEqual(out, 'Hello friend');
    });

    it('uses default when value is null', () => {
      const out = renderTemplate('Hello {{name|friend}}', { name: null });
      assert.strictEqual(out, 'Hello friend');
    });

    it('uses default when value is undefined', () => {
      const out = renderTemplate('Hello {{name|friend}}', { });
      assert.strictEqual(out, 'Hello friend');
    });

    it('preserves spaces inside default text', () => {
      const out = renderTemplate('Hello {{name|  friend  }}', {});
      assert.strictEqual(out, 'Hello   friend  ');
    });

    it('supports default text containing the pipe character', () => {
      const out = renderTemplate('Hello {{name|foo|bar}}', {});
      assert.strictEqual(out, 'Hello foo|bar');
    });

    it('supports empty default string', () => {
      const out = renderTemplate('X{{missing|}}Y', {});
      assert.strictEqual(out, 'XY');
    });
  });

  // Strict mode behavior
  describe('strict mode', () => {
    it('throws when missing value and no default', () => {
      assert.throws(
        () => renderTemplate('Hello {{name}}', {}, { strict: true }),
        (err) => err instanceof Error && /Missing value for name/.test(err.message)
      );
    });

    it('does not throw when default is provided', () => {
      const out = renderTemplate('Hello {{name|friend}}', {}, { strict: true });
      assert.strictEqual(out, 'Hello friend');
    });

    it('throws when nested value is missing and no default', () => {
      assert.throws(
        () => renderTemplate('Hi {{user.name}}', { user: {} }, { strict: true }),
        (err) => err instanceof Error && /Missing value for user\.name/.test(err.message)
      );
    });
  });

  // Path resolution with getByPath
  describe('path resolution and key formats', () => {
    it('supports nested paths with dots', () => {
      const out = renderTemplate('Hello {{user.name}}', { user: { name: 'Ada' } });
      assert.strictEqual(out, 'Hello Ada');
    });

    it('falls back to default when intermediate path is not an object', () => {
      const out = renderTemplate('Hello {{user.name|friend}}', { user: 'string' });
      assert.strictEqual(out, 'Hello friend');
    });

    it('supports keys with hyphens', () => {
      const out = renderTemplate('Hi {{user-name}}', { 'user-name': 'Bob' });
      assert.strictEqual(out, 'Hi Bob');
    });

    it('supports keys with underscores and numbers', () => {
      const out = renderTemplate('ID: {{user_1}}', { user_1: 7 });
      assert.strictEqual(out, 'ID: 7');
    });

    it('supports array index in path', () => {
      const out = renderTemplate('Item: {{items.0.name}}', { items: [{ name: 'A' }, { name: 'B' }] });
      assert.strictEqual(out, 'Item: A');
    });

    it('array path falls back to default when index missing', () => {
      const out = renderTemplate('Item: {{items.2.name|X}}', { items: [{ name: 'A' }, { name: 'B' }] });
      assert.strictEqual(out, 'Item: X');
    });
  });

  // Missing values behavior when not strict
  describe('missing values when not strict', () => {
    it('leaves placeholder unchanged when key missing and no default (strict=false)', () => {
      const out = renderTemplate('Hi {{who}}', {}, { strict: false });
      assert.strictEqual(out, 'Hi {{who}}');
    });

    it('leaves placeholder unchanged with data as non-object and no default', () => {
      const out = renderTemplate('Val: {{toString}}', 42, { strict: false });
      assert.strictEqual(out, 'Val: {{toString}}');
    });
  });

  // Handling null/undefined distinctly from false/0
  describe('null/undefined vs falsy non-null', () => {
    it('treats 0 as a valid value', () => {
      const out = renderTemplate('Zero: {{n}}', { n: 0 });
      assert.strictEqual(out, 'Zero: 0');
    });

    it('treats false as a valid value', () => {
      const out = renderTemplate('Bool: {{b}}', { b: false });
      assert.strictEqual(out, 'Bool: false');
    });

    it('treats undefined as missing (uses default)', () => {
      const out = renderTemplate('Undef: {{x|def}}', { });
      assert.strictEqual(out, 'Undef: def');
    });

    it('treats null as missing (uses default)', () => {
      const out = renderTemplate('Null: {{x|def}}', { x: null });
      assert.strictEqual(out, 'Null: def');
    });
  });

  // Multiple placeholders with mixed cases
  describe('multiple placeholders mixed cases', () => {
    it('replaces present values and applies defaults for missing', () => {
      const out = renderTemplate('Hi {{first}} {{last|Doe}}!', { first: 'John' });
      assert.strictEqual(out, 'Hi John Doe!');
    });

    it('throws on any missing without default in strict mode even if others have values', () => {
      assert.throws(
        () => renderTemplate('A {{ok}} B {{missing}}', { ok: 'K' }, { strict: true }),
        (err) => err instanceof Error && /Missing value for missing/.test(err.message)
      );
    });
  });
});