punctilio 3.7.2 → 3.7.4

package/src/tests/test-helpers.ts

@@ -1,124 +0,0 @@
-/**
- * Shared test utilities for punctilio test suites.
- */
-
-import seedrandom from "seedrandom"
-
-/**
- * Fragments covering every transform type: quotes, dashes, apostrophes,
- * ellipses, multiplication, math symbols, legal symbols, arrows, primes,
- * fractions, degrees, ordinals, nbsp-triggering short words, and plain text.
- */
-const FRAGMENTS = [
-  `"Hello," she said. `,
-  `It's a beautiful day -- isn't it? `,
-  `Wait... `,
-  `The temperature was 20 C. `,
-  `5x5 != 25. `,
-  `Add 1/2 cup. `,
-  `He's 5'10" tall. `,
-  `(c) 2024 Acme Corp. `,
-  `See p. 42 for details. `,
-  `Dr. Smith arrived. `,
-  `The 1st place winner. `,
-  `Go -> click -> done. `,
-  `Really?! No way!! `,
-  `A B C D E F G H. `,
-  `Pages 10-20 contain important info. `,
-  `January-March was cold. `,
-  `The value is -5. `,
-  `"Don't stop," he said, "keep going." `,
-  `J. K. Rowling wrote it. `,
-  `100 km in 2 hrs. `,
-]
-
-/**
- * Builds a deterministic pseudo-random string of approximately `charCount`
- * characters by randomly sampling from FRAGMENTS using a seeded PRNG.
- *
- * @param charCount - Approximate desired character count
- * @param seed - PRNG seed (default: "42")
- */
-export function buildMixedContent(charCount: number, seed: string = "42"): string {
-  const random = seedrandom(seed)
-  let result = ""
-  while (result.length < charCount) {
-    const index = Math.floor(random() * FRAGMENTS.length)
-    result += FRAGMENTS[index]
-  }
-  return result
-}
-
-/**
- * Provably linear baseline: a single regex pass that touches every char and
- * exercises the same V8 String.replace path the production transforms use.
- * Its ms/char ratio is the platform's "what linear looks like right now"
- * fingerprint — we divide fn's ratio by it to cancel shared CPU/GC noise.
- */
-const linearBaseline = (s: string): string => s.replace(/[a-z]/gi, "x")
-
-/**
- * Asserts that a function scales linearly (not quadratically) with input size.
- *
- * Compares ms/char at the two largest of 4 input sizes (4x vs 8x of startingN)
- * after a JIT warmup pass. For a linear algorithm, doubling input keeps ms/char
- * constant (ratio ~1). For a quadratic one, doubling input doubles ms/char (~2).
- *
- * Default startingN of 5000 produces inputs from ~5K to ~40K chars, which is
- * past V8's string allocation overhead inflection point where ms/char stabilizes.
- *
- * Each trial measures `fn` and a known-linear baseline back-to-back at both
- * sizes, then divides `fn`'s 8x/4x ratio by the baseline's. Shared platform
- * noise (CPU contention, scheduler jitter) inflates both numerator and
- * denominator and cancels out; only `fn`-specific super-linear growth pushes
- * the normalized ratio past 1. Min across trials picks the cleanest sample.
- *
- * @param fn - The function to benchmark
- * @param buildInput - Builds an input string of approximately `n` units
- * @param startingN - Size parameter for the smallest input (default: 5000)
- */
-export function assertLinearScaling(
-  fn: (input: string) => unknown,
-  buildInput: (n: number) => string,
-  startingN: number = 5000
-): void {
-  const input4x = buildInput(startingN * 4)
-  const input8x = buildInput(startingN * 8)
-
-  // Warmup both with the largest input so JIT compiles all code paths.
-  fn(input8x)
-  linearBaseline(input8x)
-
-  const minTrials = 8
-  const minElapsedMs = 200
-  let bestRatio = Infinity
-  let totalElapsed = 0
-  let trials = 0
-  while (trials < minTrials || totalElapsed < minElapsedMs) {
-    const startFn4 = performance.now()
-    fn(input4x)
-    const fnTime4 = performance.now() - startFn4
-
-    const startBase4 = performance.now()
-    linearBaseline(input4x)
-    const baseTime4 = performance.now() - startBase4
-
-    const startFn8 = performance.now()
-    fn(input8x)
-    const fnTime8 = performance.now() - startFn8
-
-    const startBase8 = performance.now()
-    linearBaseline(input8x)
-    const baseTime8 = performance.now() - startBase8
-
-    const fnRatio = (fnTime8 / input8x.length) / (fnTime4 / input4x.length)
-    const baseRatio = (baseTime8 / input8x.length) / (baseTime4 / input4x.length)
-    const ratio = fnRatio / baseRatio
-    bestRatio = Math.min(bestRatio, ratio)
-    totalElapsed += fnTime4 + fnTime8 + baseTime4 + baseTime8
-    trials++
-  }
-
-  // After baseline-normalization: linear ≈ 1, quadratic ≈ 2.
-  expect(bestRatio).toBeLessThan(1.5)
-}

package/src/tests/utils.test.ts

@@ -1,151 +0,0 @@
-import { jest } from "@jest/globals"
-import { assertSeparatorAbsent, countSeparators, assertSeparatorCountPreserved, formatErrorString } from "../utils.js"
-import { DEFAULT_SEPARATOR, cachedRegExp, clearRegexCache } from "../constants.js"
-
-describe("assertSeparatorAbsent", () => {
-  it.each([
-    ["no values", [], DEFAULT_SEPARATOR],
-    ["clean values", ["hello", "world"], DEFAULT_SEPARATOR],
-  ])("does not throw: %s", (_desc, values, separator) => {
-    expect(() => assertSeparatorAbsent(values, separator)).not.toThrow()
-  })
-
-  it.each([
-    ["default separator", [`hello${DEFAULT_SEPARATOR}world`], DEFAULT_SEPARATOR, /U\+E000 U\+E001/],
-    ["custom separator", ["hello|world"], "|", /U\+007C/],
-    ["separator in middle element", ["clean", `has${DEFAULT_SEPARATOR}sep`, "also clean"], DEFAULT_SEPARATOR, /separator sequence/],
-  ])("throws: %s", (_desc, values, separator, expectedPattern) => {
-    expect(() => assertSeparatorAbsent(values, separator)).toThrow(expectedPattern)
-  })
-})
-
-describe("countSeparators", () => {
-  it.each([
-    ["empty string", "", DEFAULT_SEPARATOR, 0],
-    ["no separators", "hello world", DEFAULT_SEPARATOR, 0],
-    ["single separator", `a${DEFAULT_SEPARATOR}b`, DEFAULT_SEPARATOR, 1],
-    ["multiple separators", `${DEFAULT_SEPARATOR}a${DEFAULT_SEPARATOR}b${DEFAULT_SEPARATOR}`, DEFAULT_SEPARATOR, 3],
-    ["consecutive separators", `${DEFAULT_SEPARATOR}${DEFAULT_SEPARATOR}${DEFAULT_SEPARATOR}`, DEFAULT_SEPARATOR, 3],
-    ["custom separator", "a|b|c", "|", 2],
-  ])("%s: counts correctly", (_desc, input, separator, expected) => {
-    expect(countSeparators(input, separator)).toBe(expected)
-  })
-
-  it.each([
-    [`a${DEFAULT_SEPARATOR}b`, 1],
-    ["no separators", 0],
-    [`${DEFAULT_SEPARATOR}${DEFAULT_SEPARATOR}`, 2],
-  ])("uses DEFAULT_SEPARATOR when omitted: %s -> %i", (input, expected) => {
-    expect(countSeparators(input)).toBe(expected)
-  })
-})
-
-describe("assertSeparatorCountPreserved", () => {
-  describe("does not throw when count preserved", () => {
-    it.each([
-      ["same count", `a${DEFAULT_SEPARATOR}b`, `x${DEFAULT_SEPARATOR}y`],
-      ["zero count", "ab", "xy"],
-      ["multiple preserved", `${DEFAULT_SEPARATOR}a${DEFAULT_SEPARATOR}b${DEFAULT_SEPARATOR}`, `${DEFAULT_SEPARATOR}x${DEFAULT_SEPARATOR}y${DEFAULT_SEPARATOR}`],
-    ])("%s", (_desc, original, transformed) => {
-      expect(() => assertSeparatorCountPreserved(original, transformed, DEFAULT_SEPARATOR, "test")).not.toThrow()
-    })
-  })
-
-  describe("throws when count changes", () => {
-    it.each([
-      ["separator removed", `a${DEFAULT_SEPARATOR}b`, "ab", 1, 0],
-      ["separator added", "ab", `a${DEFAULT_SEPARATOR}b`, 0, 1],
-      ["multiple removed", `${DEFAULT_SEPARATOR}${DEFAULT_SEPARATOR}`, "", 2, 0],
-    ])("%s: expected %i, got %i", (_desc, original, transformed, expectedCount, actualCount) => {
-      expect(() => assertSeparatorCountPreserved(original, transformed, DEFAULT_SEPARATOR, "testFn"))
-        .toThrow(`testFn altered separator count: expected ${expectedCount}, got ${actualCount}`)
-    })
-  })
-
-  describe("default parameters", () => {
-    it.each([
-      ["throws when separator lost", `a${DEFAULT_SEPARATOR}b`, "ab", true],
-      ["does not throw when preserved", `a${DEFAULT_SEPARATOR}b`, `x${DEFAULT_SEPARATOR}y`, false],
-    ])("%s", (_desc, original, transformed, shouldThrow) => {
-      if (shouldThrow) {
-        expect(() => assertSeparatorCountPreserved(original, transformed)).toThrow()
-      } else {
-        expect(() => assertSeparatorCountPreserved(original, transformed)).not.toThrow()
-      }
-    })
-  })
-})
-
-describe("cachedRegExp", () => {
-  afterEach(() => {
-    clearRegexCache()
-  })
-
-  it("evicts entries when cache exceeds max size", () => {
-    // Fill the cache well beyond 1000 entries with unique patterns
-    for (let i = 0; i < 1010; i++) {
-      const re = cachedRegExp(`unique-pattern-${i}`, "g")
-      expect(re).toBeInstanceOf(RegExp)
-    }
-    // Verify the cache still works correctly after eviction
-    const re = cachedRegExp("unique-pattern-1009", "g")
-    expect(re.source).toBe("unique-pattern-1009")
-  })
-})
-
-describe("formatErrorString", () => {
-  let stderrOutput: string[]
-  let stderrSpy: jest.SpiedFunction<typeof process.stderr.write>
-
-  beforeEach(() => {
-    stderrOutput = []
-    stderrSpy = jest.spyOn(process.stderr, "write").mockImplementation((chunk: string | Uint8Array) => {
-      stderrOutput.push(String(chunk))
-      return true
-    })
-  })
-
-  afterEach(() => {
-    stderrSpy.mockRestore()
-  })
-
-  it("returns JSON-stringified content for short strings", () => {
-    const result = formatErrorString("short text", "test")
-    expect(result).toBe('"short text"')
-    expect(stderrOutput).toHaveLength(0)
-  })
-
-  it("truncates strings over 2000 chars with label and length", () => {
-    const longText = "x".repeat(2001)
-    const result = formatErrorString(longText, "long-test")
-
-    expect(result).toContain("[long-test:")
-    expect(result).toContain("2001 chars total")
-    expect(result).toContain("...")
-  })
-
-  it("includes first 2000 chars in truncated output", () => {
-    const longText = "a".repeat(1500) + "b".repeat(1000)
-    const result = formatErrorString(longText, "mixed")
-
-    const expected2000 = "a".repeat(1500) + "b".repeat(500)
-    expect(result).toContain(JSON.stringify(expected2000))
-    expect(result).toContain("2500 chars total")
-  })
-
-  it("writes full content to stderr in Node.js for long strings", () => {
-    const longText = "z".repeat(2001)
-    formatErrorString(longText, "stderr-test")
-
-    expect(stderrOutput).toHaveLength(1)
-    expect(stderrOutput[0]).toContain("punctilio stderr-test full content")
-    expect(stderrOutput[0]).toContain(longText)
-  })
-
-  it("handles strings at exactly the threshold", () => {
-    const exactText = "x".repeat(2000)
-    const result = formatErrorString(exactText, "exact")
-    expect(result).toBe(JSON.stringify(exactText))
-    expect(stderrOutput).toHaveLength(0)
-  })
-})