@design-core/core 0.0.5 → 0.0.7

package/test/test-helpers/hatchGridRenderer.js

@@ -0,0 +1,180 @@
+/**
+ * Shared hatch pattern grid renderer.
+ *
+ * Draws a full hatch-pattern reference sheet onto any RendererBase-compatible
+ * renderer: a 10-column grid of all 82 hatch patterns (alternating square and
+ * circle boundaries), pattern name labels, a 5 mm border rectangle, and a
+ * title.  Used by both the PDF and SVG integration tests so the visual output
+ * stays identical across renderer implementations.
+ *
+ * Usage:
+ *   const renderer = new SomeRenderer(PAGE_W, PAGE_H);
+ *   buildHatchGrid(renderer);
+ *   const output = renderer.getOutput();
+ */
+
+import { Core } from '../../core/core/core.js';
+import { Hatch } from '../../core/entities/hatch.js';
+import { BasePolyline } from '../../core/entities/basePolyline.js';
+import { Point } from '../../core/entities/point.js';
+import { Text } from '../../core/entities/text.js';
+
+// ─── Page & grid constants ────────────────────────────────────────────────────
+
+export const PAGE_W = 1190; // landscape A3
+export const PAGE_H = 842;
+export const MARGIN = 5 * 72 / 25.4; // 5 mm in points ≈ 14.17
+
+export const COLS = 10;
+export const CELL_W = 115;
+export const CELL_H = 85;
+export const SHAPE_R = 32; // half-side of square / radius of circle (64 pt total)
+export const LABEL_FONT = 6;
+export const TITLE_FONT = 14;
+
+// ─── All hatch patterns ───────────────────────────────────────────────────────
+
+export const PATTERNS = [
+  'SOLID',
+  'ANGLE', 'ANSI31', 'ANSI32', 'ANSI33', 'ANSI34', 'ANSI35', 'ANSI36', 'ANSI37', 'ANSI38',
+  'AR-B816', 'AR-B816C', 'AR-B88', 'AR-BRELM', 'AR-BRSTD', 'AR-CONC',
+  'AR-HBONE', 'AR-PARQ1', 'AR-RROOF', 'AR-RSHKE', 'AR-SAND',
+  'BOX', 'BRASS', 'BRICK', 'BRSTONE', 'CLAY', 'CORK', 'CROSS',
+  'DASH', 'DOLMIT', 'DOTS', 'EARTH', 'ESCHER', 'FLEX',
+  'GOST_GLASS', 'GOST_WOOD', 'GOST_GROUND', 'GRASS', 'GRATE', 'GRAVEL',
+  'HEX', 'HONEY', 'HOUND', 'INSUL',
+  'ACAD_ISO02W100', 'ACAD_ISO03W100', 'ACAD_ISO04W100', 'ACAD_ISO05W100',
+  'ACAD_ISO06W100', 'ACAD_ISO07W100', 'ACAD_ISO08W100', 'ACAD_ISO09W100',
+  'ACAD_ISO10W100', 'ACAD_ISO11W100', 'ACAD_ISO12W100', 'ACAD_ISO13W100',
+  'ACAD_ISO14W100', 'ACAD_ISO15W100',
+  'JIS_LC_20', 'JIS_LC_20A', 'JIS_LC_8', 'JIS_LC_8A',
+  'JIS_RC_10', 'JIS_RC_15', 'JIS_RC_18', 'JIS_RC_30', 'JIS_STN_1E', 'JIS_WOOD',
+  'LINE', 'MUDST', 'NET', 'NET3', 'PLAST', 'PLASTI',
+  'SACNCR', 'SQUARE', 'STARS', 'STEEL', 'SWAMP', 'TRANS', 'TRIANG', 'ZIGZAG',
+];
+
+// ─── Private helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Return n evenly-spaced {x, y} points around a circle.
+ * Used to draw a visible circle outline via straight-line segments
+ * (renderers that lack native arc support use chord approximation).
+ *
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} r
+ * @param {number} [n=32]
+ * @return {{x: number, y: number}[]}
+ */
+function circleOutlinePoints(cx, cy, r, n = 32) {
+  const pts = [];
+  for (let k = 0; k < n; k++) {
+    const a = (k / n) * 2 * Math.PI;
+    pts.push({ x: cx + r * Math.cos(a), y: cy + r * Math.sin(a) });
+  }
+  return pts;
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Draw the hatch pattern reference sheet onto `renderer`.
+ *
+ * Sets up an identity transform then draws:
+ *  - A 5 mm border rectangle
+ *  - A "Hatch Pattern Reference" title
+ *  - A 10-column grid of all 82 hatch patterns, alternating square and circle
+ *    boundaries, with pattern name labels beneath each shape
+ *
+ * `new Core()` is called internally because Hatch.draw() requires
+ * DesignCore.Scene.selectionManager to be present.
+ *
+ * @param {object} renderer
+ */
+export function buildHatchGrid(renderer) {
+  // Required so that Hatch.draw() can access DesignCore.Scene.selectionManager
+  new Core();
+
+  // Identity transform — draw directly in page coordinates (Y-up, 1 unit = 1 pt)
+  renderer.setTransform({ a: 1, d: 1, e: 0, f: 0 });
+
+  // Border rectangle inset 5 mm from each edge
+  renderer.setColour({ r: 0, g: 0, b: 0 });
+  renderer.setLineWidth(1);
+  renderer.setDash([], 0);
+  renderer.drawShape([
+    { x: MARGIN, y: MARGIN },
+    { x: PAGE_W - MARGIN, y: MARGIN },
+    { x: PAGE_W - MARGIN, y: PAGE_H - MARGIN },
+    { x: MARGIN, y: PAGE_H - MARGIN },
+  ], { closed: true, stroke: true });
+
+  // Title
+  const title = 'Hatch Pattern Reference';
+  const titleX = PAGE_W / 2 - Text.getApproximateWidth(title, TITLE_FONT) / 2;
+  const titleY = PAGE_H - MARGIN - TITLE_FONT - 2;
+  renderer.setColour({ r: 0, g: 0, b: 0 });
+  renderer.setLineWidth(0.5);
+  renderer.drawText([{ char: title, x: titleX, y: titleY, rotation: 0 }], 'Helvetica', TITLE_FONT);
+
+  // Grid — centred horizontally, starting below the title
+  const xGrid = (PAGE_W - COLS * CELL_W) / 2;
+  const yGridTop = titleY - TITLE_FONT - 8;
+
+  PATTERNS.forEach((name, i) => {
+    const row = Math.floor(i / COLS);
+    const col = i % COLS;
+    const cellX = xGrid + col * CELL_W;
+    const cellYTop = yGridTop - row * CELL_H;
+
+    // Shape centre: 4 pt top padding + SHAPE_R inside the cell
+    const cx = cellX + CELL_W / 2;
+    const cy = cellYTop - 4 - SHAPE_R;
+
+    // Alternate square (even index) and circle (odd index) boundaries
+    let hatchBoundary;
+    let outlinePoints;
+
+    if (i % 2 === 0) {
+      hatchBoundary = new BasePolyline({ points: [
+        new Point(cx - SHAPE_R, cy - SHAPE_R),
+        new Point(cx + SHAPE_R, cy - SHAPE_R),
+        new Point(cx + SHAPE_R, cy + SHAPE_R),
+        new Point(cx - SHAPE_R, cy + SHAPE_R),
+      ] });
+      outlinePoints = hatchBoundary.toPolylinePoints();
+    } else {
+      // Two exact semicircle arcs (bulge = 1) for clipping; polygon for visible outline
+      hatchBoundary = new BasePolyline({ points: [
+        new Point(cx + SHAPE_R, cy, 1),
+        new Point(cx - SHAPE_R, cy, 1),
+      ] });
+      outlinePoints = circleOutlinePoints(cx, cy, SHAPE_R);
+    }
+
+    // AR-* patterns have large inter-line spacing; scale down so lines are visible
+    const scale = name.startsWith('AR-') ? 0.1 : 1;
+    const hatch = new Hatch({ patternName: name, scale });
+    hatch.setProperty('childEntities', [hatchBoundary]);
+    hatch.buildPatternCache();
+
+    // Draw hatch fill
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(0.25);
+    renderer.setDash([], 0);
+    hatch.draw(renderer);
+
+    // Draw boundary outline on top
+    renderer.setColour({ r: 0, g: 0, b: 0 });
+    renderer.setLineWidth(0.5);
+    renderer.setDash([], 0);
+    renderer.drawShape(outlinePoints, { closed: true, stroke: true });
+
+    // Pattern name label, centred below the shape
+    const labelY = cellYTop - 4 - SHAPE_R * 2 - LABEL_FONT - 2;
+    const labelX = cellX + (CELL_W - Text.getApproximateWidth(name, LABEL_FONT)) / 2;
+    renderer.setColour({ r: 60, g: 60, b: 60 });
+    renderer.setLineWidth(0.25);
+    renderer.drawText([{ char: name, x: labelX, y: labelY, rotation: 0 }], 'Helvetica', LABEL_FONT);
+  });
+}

package/test/test-helpers/test-helpers.js

@@ -40,6 +40,7 @@ export async function withMockInput(scene, inputs, testFn, options = {}) {
         return inputs[callCount++];
       }
     },
+    actionCommand: () => {},
     executeCommand: () => {},
     reset: () => {},
     ...extraMethods,
@@ -64,3 +65,154 @@ export async function withMockInput(scene, inputs, testFn, options = {}) {
   }
 }
 
+/**
+ * A minimal RendererBase-compatible mock for use in unit tests.
+ *
+ * Tracks colour, line width and dash state so tests can assert on them.
+ * Optionally accepts a spy context object; when provided, `save`, `restore`
+ * and `applyTransform` delegate to it so tests can verify save/restore
+ * balance and transform calls via the context's own spies.
+ *
+ * @example
+ * const renderer = new MockRenderer();
+ * entity.draw(renderer);
+ * expect(renderer.strokeStyle).toBe('rgb(255,0,0)');
+ *
+ * @example
+ * const ctx = createSpyContext();
+ * const renderer = new MockRenderer(ctx);
+ * canvas.paint(ctx, 800, 600);
+ * expect(ctx.saveDepth).toBe(0); // all saves balanced
+ */
+export class MockRenderer {
+  /**
+   * @param {object|null} [ctx=null] - optional spy context to delegate save/restore to
+   */
+  constructor(ctx = null) {
+    this._ctx = ctx;
+    this.strokeStyle = '';
+    this.fillStyle = '';
+    this.lineWidth = 0;
+    this.dashPattern = null;
+  }
+
+  /** @param {{ r: number, g: number, b: number }} rgb */
+  setColour(rgb) {
+    this.strokeStyle = `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`;
+    this.fillStyle = this.strokeStyle;
+    if (this._ctx) {
+      this._ctx.strokeStyle = this.strokeStyle;
+      this._ctx.fillStyle = this.fillStyle;
+    }
+  }
+
+  /** @param {number} w */
+  setLineWidth(w) {
+    this.lineWidth = w;
+    if (this._ctx) this._ctx.lineWidth = w;
+  }
+
+  /** @param {number[]} pattern */
+  setDash(pattern) {
+    this.dashPattern = pattern;
+  }
+
+  /** @param {object} matrix */
+  setTransform(matrix) {}
+
+  /** @param {Function} styleTransform */
+  setStyle(styleTransform) {
+    this._styleTransform = styleTransform;
+  }
+
+  /** @param {{ r: number, g: number, b: number }|null} colour */
+  setBackgroundColour(colour) {
+    this._backgroundColour = colour;
+  }
+
+  /** @return {{ r: number, g: number, b: number }|null} */
+  /**
+   * @return {object|null}
+   */
+  getBackgroundColour() {
+    return this._backgroundColour ?? null;
+  }
+
+  /** */
+  fillBackground() {}
+
+  /**
+   * @param {Array} points
+   * @param {object} [options]
+   */
+  drawShape(points, options) {}
+
+  /**
+   * @param {Array} characters
+   * @param {string} fontName
+   * @param {number} height
+   */
+  drawText(characters, fontName, height) {}
+
+  /** Save current drawing state. */
+  save() {
+    if (this._ctx) this._ctx.save();
+  }
+
+  /** Restore previously saved drawing state. */
+  restore() {
+    if (this._ctx) this._ctx.restore();
+  }
+
+  /**
+   * @param {object} [transform]
+   * @param {number} [transform.x=0]
+   * @param {number} [transform.y=0]
+   */
+  applyTransform({ x = 0, y = 0 } = {}) {
+    if (this._ctx) this._ctx.translate(x, y);
+  }
+
+  /**
+   * @param {boolean} [isHighlighted=false]
+   * @param {object|null} [colour=null]
+   * @param {number} [lineWidthDelta=0]
+   */
+  setHighlight(isHighlighted = false, colour = null, lineWidthDelta = 0) {
+    this.isHighlighted = isHighlighted;
+    this.highlightColour = colour;
+    this.highlightLineWidthDelta = lineWidthDelta;
+  }
+
+  /** @return {number} */
+  measureText() {
+    return 0;
+  }
+
+  /** @return {number} */
+  measureCharWidth() {
+    return 0;
+  }
+
+  /**
+   * @param {Array} [segments]
+   * @param {Array} [dashes]
+   */
+  drawSegments(segments, dashes) {}
+
+  /** @param {Array} [points] */
+  tracePath(points) {}
+
+  /** Start a new path. */
+  beginPath() {}
+
+  /** Stroke the current path. */
+  stroke() {}
+
+  /** Close the current path. */
+  closePath() {}
+
+  /** @param {object} [options] */
+  applyPath(options) {}
+}
+

package/test/tools/chamfer.test.js

@@ -1,6 +1,7 @@
 import { Core } from '../../core/core/core.js';
 import { Point } from '../../core/entities/point.js';
 import { Chamfer } from '../../core/tools/chamfer.js';
+import { DesignCore } from '../../core/designCore.js';
 import { Strings } from '../../core/lib/strings.js';
 import { SingleSelection } from '../../core/lib/selectionManager.js';
 import { expect, jest } from '@jest/globals';
@@ -872,11 +873,20 @@ test('Chamfer.action dist>0 trimMode=true closed Lwpolyline closing-wrap (seg4+s
   const poly = core.scene.entities.get(0);
   // Shared vertex (0,0) at index 0 replaced by two chamfer points → total 5 points
   expect(poly.points.length).toBe(5);
-  // Endpoints must NOT have been moved to the intersection (open-ends symptom)
-  // The first two new points should be the chamfer points, not (0,0)/(0,0)
-  const allAtOrigin = poly.points[0].x === 0 && poly.points[0].y === 0 &&
-    poly.points[1].x === 0 && poly.points[1].y === 0;
-  expect(allAtOrigin).toBe(false);
+  // Verify the actual chamfer point coordinates and traversal order.
+  // The closing segment (0,10)→(0,0) is chamfered at (0,2),
+  // seg 1 (0,0)→(10,0) is chamfered at (2,0).
+  // After splice: [(0,2), (2,0), (10,0), (10,10), (0,10)]
+  expect(poly.points[0].x).toBeCloseTo(0);
+  expect(poly.points[0].y).toBeCloseTo(2);
+  expect(poly.points[1].x).toBeCloseTo(2);
+  expect(poly.points[1].y).toBeCloseTo(0);
+  expect(poly.points[2].x).toBeCloseTo(10);
+  expect(poly.points[2].y).toBeCloseTo(0);
+  expect(poly.points[3].x).toBeCloseTo(10);
+  expect(poly.points[3].y).toBeCloseTo(10);
+  expect(poly.points[4].x).toBeCloseTo(0);
+  expect(poly.points[4].y).toBeCloseTo(10);
 });
 
 test('Chamfer.action dist>0 trimMode=false closed Lwpolyline closing-wrap: standalone chamfer Line only', () => {
@@ -968,3 +978,215 @@ test('Chamfer.action dist>0 trimMode=false Line + Lwpolyline: standalone chamfer
   expect(core.scene.entities.get(0).points.length).toBe(2);
   expect(core.scene.entities.get(1).points.length).toBe(4);
 });
+
+// ─── action: entity property inheritance ─────────────────────────────────────
+
+test('Chamfer.action chamfer line inherits layer, lineWidth, lineType from first entity', () => {
+  // Perpendicular L-corner at origin; first entity on a non-default layer.
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)], layer: 'walls', lineWidth: 5, lineType: 'DASHED' });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+
+  core.scene.headers.chamferDistanceA = 2;
+  core.scene.headers.chamferDistanceB = 2;
+  core.scene.headers.chamferMode = false;
+  core.scene.headers.trimMode = false;
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.secondPick.entity = core.scene.entities.get(1);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+  chamfer.secondPick.clickPoint = new Point(0, 5);
+  chamfer.action();
+
+  expect(core.scene.entities.count()).toBe(3);
+  const chamferLine = core.scene.entities.get(2);
+  expect(chamferLine.type).toBe('Line');
+  expect(chamferLine.getProperty('layer')).toBe('walls');
+  expect(chamferLine.getProperty('lineWidth')).toBe(5);
+  expect(chamferLine.getProperty('lineType')).toBe('DASHED');
+});
+
+test('Chamfer.preview does not throw', () => {
+  const chamfer = new Chamfer();
+  expect(() => chamfer.preview()).not.toThrow();
+});
+
+test('Chamfer.preview returns early when findClosestItem returns undefined', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(undefined);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  chamfer.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Chamfer.preview adds chamfer line to previewEntities in no-trim mode', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  core.scene.headers.chamferDistanceA = 2;
+  core.scene.headers.chamferDistanceB = 2;
+  core.scene.headers.chamferMode = false;
+  core.scene.headers.trimMode = false;
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  chamfer.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThanOrEqual(1);
+});
+
+test('Chamfer.preview skips chamfer line in no-trim mode when distances are both 0 (sharp corner)', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  core.scene.headers.chamferDistanceA = 0;
+  core.scene.headers.chamferDistanceB = 0;
+  core.scene.headers.chamferMode = false;
+  core.scene.headers.trimMode = false;
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  chamfer.preview();
+  findSpy.mockRestore();
+
+  expect(DesignCore.Scene.previewEntities.count()).toBe(0);
+});
+
+test('Chamfer.preview adds 5 entities to previewEntities in trim mode', () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+  DesignCore.Scene.previewEntities.clear();
+
+  core.scene.headers.chamferDistanceA = 2;
+  core.scene.headers.chamferDistanceB = 2;
+  core.scene.headers.chamferMode = false;
+  core.scene.headers.trimMode = true;
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+
+  const findSpy = jest.spyOn(core.scene.selectionManager, 'findClosestItem').mockReturnValue(1);
+  DesignCore.Mouse.pointOnScene = () => new Point(0, 5);
+  chamfer.preview();
+  findSpy.mockRestore();
+
+  // dulled firstSeg + dulled secondSeg + firstTrimLine + secondTrimLine + chamferLine = 5
+  expect(DesignCore.Scene.previewEntities.count()).toBeGreaterThanOrEqual(5);
+});
+
+test('Chamfer.execute returns early when second-entity input is undefined (inner loop)', async () => {
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+
+  const executeCommandSpy = jest.fn();
+  await withMockInput(
+      core.scene,
+      [new SingleSelection(0, new Point(-5, 0))],
+      async () => {
+        const chamfer = new Chamfer();
+        await chamfer.execute();
+        expect(executeCommandSpy).not.toHaveBeenCalled();
+      },
+      { extraMethods: { executeCommand: executeCommandSpy } },
+  );
+});
+
+test('Chamfer.execute notifies NONCONSECUTIVESEGMENTS for non-adjacent polyline segments', async () => {
+  // 5-point polyline → 4 segments. Pick segment 1 (near -15,0) then segment 3 (near 5,0).
+  // Neither consecutive nor open-ends → NONCONSECUTIVESEGMENTS, then undefined to exit.
+  core.scene.clear();
+  core.scene.addItem('Lwpolyline', { points: [new Point(-20, 0), new Point(-10, 0), new Point(0, 0), new Point(10, 0), new Point(20, 0)] });
+
+  const notifySpy = jest.spyOn(core, 'notify');
+  await withMockInput(
+      core.scene,
+      [new SingleSelection(0, new Point(-15, 0)), new SingleSelection(0, new Point(5, 0)), undefined],
+      async () => {
+        const chamfer = new Chamfer();
+        await chamfer.execute();
+      },
+  );
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Message.NONCONSECUTIVESEGMENTS));
+  notifySpy.mockRestore();
+});
+
+test('Chamfer.execute Method→Distance sets chamferMode to false', async () => {
+  core.scene.headers.chamferMode = true;
+
+  await withMockInput(
+      core.scene,
+      ['Method', 'Distance', undefined],
+      async () => {
+        const chamfer = new Chamfer();
+        await chamfer.execute();
+      },
+  );
+
+  expect(core.scene.headers.chamferMode).toBe(false);
+});
+
+test('Chamfer.execute Trim→Trim keeps trimMode=true', async () => {
+  core.scene.headers.trimMode = true;
+
+  await withMockInput(
+      core.scene,
+      ['Trim', 'Trim', undefined],
+      async () => {
+        const chamfer = new Chamfer();
+        await chamfer.execute();
+      },
+  );
+
+  expect(core.scene.headers.trimMode).toBe(true);
+});
+
+test('Chamfer.action angle method angle=180 notifies INVALIDNUMBER', () => {
+  // alpha = 180 * π/180 = π; checks alpha >= Math.PI → INVALIDNUMBER
+  core.scene.clear();
+  core.scene.addItem('Line', { points: [new Point(-10, 0), new Point(0, 0)] });
+  core.scene.addItem('Line', { points: [new Point(0, 0), new Point(0, 10)] });
+
+  core.scene.headers.chamferLength = 2;
+  core.scene.headers.chamferAngle = 180;
+  core.scene.headers.chamferMode = true;
+  core.scene.headers.trimMode = true;
+
+  const notifySpy = jest.spyOn(core, 'notify');
+
+  const chamfer = new Chamfer();
+  chamfer.firstPick.entity = core.scene.entities.get(0);
+  chamfer.secondPick.entity = core.scene.entities.get(1);
+  chamfer.firstPick.clickPoint = new Point(-5, 0);
+  chamfer.secondPick.clickPoint = new Point(0, 5);
+  chamfer.action();
+
+  expect(notifySpy).toHaveBeenCalledWith(expect.stringContaining(Strings.Error.INVALIDNUMBER));
+  expect(core.scene.entities.count()).toBe(2);
+  notifySpy.mockRestore();
+});