@design-core/core 0.0.1 → 0.0.3

package/test/entities/point.test.js

@@ -1,5 +1,5 @@
 
-import {Point} from '../../core/entities/point.js';
+import { Point } from '../../core/entities/point.js';
 
 
 test('Test Point.add', () => {
@@ -40,19 +40,19 @@ test('Test Point.angle', () => {
   expect(pt1.angle(new Point(10, 0))).toBe(0);
 
   /* 22.5 degrees */
-  expect(pt1.angle(new Point(13.065629648764, 5.411961001462))).toBeCloseTo(Math.PI/8);
+  expect(pt1.angle(new Point(13.065629648764, 5.411961001462))).toBeCloseTo(Math.PI / 8);
 
   /* 45 degrees */
-  expect(pt1.angle(new Point(10, 10))).toBe(Math.PI/4);
+  expect(pt1.angle(new Point(10, 10))).toBe(Math.PI / 4);
 
   /* 90 degrees */
-  expect(pt1.angle(new Point(0, 10))).toBe(Math.PI/2);
+  expect(pt1.angle(new Point(0, 10))).toBe(Math.PI / 2);
 
   /* 180 degrees */
   expect(pt1.angle(new Point(-10, 0))).toBe(Math.PI);
 
   /* 270 degrees */
-  expect(pt1.angle(new Point(0, -10))).toBe(Math.PI*1.5);
+  expect(pt1.angle(new Point(0, -10))).toBe(Math.PI * 1.5);
 });
 
 test('Test Point.clone', () => {
@@ -86,18 +86,87 @@ test('Test Point.dot', () => {
   expect(pt1.dot(pt3)).toBe(-200);
 });
 
+test('Test Point.cross', () => {
+  // Perpendicular vectors
+  const pt1 = new Point(1, 0);
+  const pt2 = new Point(0, 1);
+  expect(pt1.cross(pt2)).toBe(1);
+
+  // Reversed order negates the result
+  expect(pt2.cross(pt1)).toBe(-1);
+
+  // Parallel vectors
+  const pt3 = new Point(2, 0);
+  expect(pt1.cross(pt3)).toBe(0);
+});
+
+test('Test Point.mirror', () => {
+  // Mirror across the X axis (y=0 line: from (0,0) to (1,0))
+  const xAxisPt1 = new Point(0, 0);
+  const xAxisPt2 = new Point(1, 0);
+  const pt1 = new Point(3, 4);
+  const r1 = pt1.mirror(xAxisPt1, xAxisPt2);
+  expect(r1.x).toBeCloseTo(3);
+  expect(r1.y).toBeCloseTo(-4);
+
+  // Mirror across the Y axis (x=0 line: from (0,0) to (0,1))
+  const yAxisPt1 = new Point(0, 0);
+  const yAxisPt2 = new Point(0, 1);
+  const pt2 = new Point(5, 3);
+  const r2 = pt2.mirror(yAxisPt1, yAxisPt2);
+  expect(r2.x).toBeCloseTo(-5);
+  expect(r2.y).toBeCloseTo(3);
+
+  // Mirror across a diagonal line y=x (from (0,0) to (1,1))
+  const diagPt1 = new Point(0, 0);
+  const diagPt2 = new Point(1, 1);
+  const pt3 = new Point(3, 0);
+  const r3 = pt3.mirror(diagPt1, diagPt2);
+  expect(r3.x).toBeCloseTo(0);
+  expect(r3.y).toBeCloseTo(3);
+
+  // A point on the mirror line is unchanged
+  const pt4 = new Point(2, 0);
+  const r4 = pt4.mirror(xAxisPt1, xAxisPt2);
+  expect(r4.x).toBeCloseTo(2);
+  expect(r4.y).toBeCloseTo(0);
+
+  // Mirror across an offset vertical line (x=5)
+  const vPt1 = new Point(5, 0);
+  const vPt2 = new Point(5, 1);
+  const pt5 = new Point(3, 2);
+  const r5 = pt5.mirror(vPt1, vPt2);
+  expect(r5.x).toBeCloseTo(7);
+  expect(r5.y).toBeCloseTo(2);
+
+  // Bulge is negated (arc direction reverses)
+  const pt6 = new Point(3, 4, 0.5, 10);
+  const r6 = pt6.mirror(xAxisPt1, xAxisPt2);
+  expect(r6.bulge).toBeCloseTo(-0.5);
+  expect(r6.sequence).toBe(10);
+
+  // Degenerate mirror line (pt1 === pt2) returns a clone of the point unchanged
+  const ptDegen = new Point(7, 8, 0.25, 3);
+  const samePt = new Point(5, 5);
+  const rDegen = ptDegen.mirror(samePt, samePt);
+  expect(rDegen.x).toBeCloseTo(7);
+  expect(rDegen.y).toBeCloseTo(8);
+  expect(rDegen.bulge).toBeCloseTo(0.25);
+  expect(rDegen.sequence).toBe(3);
+});
+
 test('Test Point.rotate', () => {
   const centre = new Point();
 
   /* 90 degrees */
   const pt1 = new Point(10, 0);
-  const result1 = pt1.rotate(centre, Math.PI/2);
+  const result1 = pt1.rotate(centre, Math.PI / 2);
   expect(result1.x).toBeCloseTo(0, 5);
   expect(result1.y).toBeCloseTo(10, 5);
 
   /* -90 degrees */
   const pt2 = new Point(-10, 0);
-  const result2 = pt2.rotate(centre, -Math.PI/2);
+  const result2 = pt2.rotate(centre, -Math.PI / 2);
   expect(result2.x).toBeCloseTo(0, 5);
   expect(result2.y).toBeCloseTo(10, 5);
 
@@ -110,6 +179,114 @@ test('Test Point.rotate', () => {
   expect(result3.y).toBeCloseTo(30, 5);
 });
 
+test('Test Point.length', () => {
+  expect(new Point(3, 4).length()).toBe(5);
+  expect(new Point(5, 0).length()).toBe(5);
+  expect(new Point(0, -7).length()).toBe(7);
+  expect(new Point(0, 0).length()).toBe(0);
+  expect(new Point(1, 1).length()).toBeCloseTo(Math.SQRT2);
+});
+
+test('Test Point.normalise', () => {
+  // Axis-aligned vector: (5, 0) → (1, 0)
+  const pt1 = new Point(5, 0);
+  const r1 = pt1.normalise();
+  expect(r1.x).toBeCloseTo(1);
+  expect(r1.y).toBeCloseTo(0);
+
+  // Axis-aligned vector: (0, -3) → (0, -1)
+  const pt2 = new Point(0, -3);
+  const r2 = pt2.normalise();
+  expect(r2.x).toBeCloseTo(0);
+  expect(r2.y).toBeCloseTo(-1);
+
+  // Diagonal vector: (3, 4) has length 5 → (0.6, 0.8)
+  const pt3 = new Point(3, 4);
+  const r3 = pt3.normalise();
+  expect(r3.x).toBeCloseTo(0.6);
+  expect(r3.y).toBeCloseTo(0.8);
+
+  // Result is a unit vector: length = 1
+  const pt4 = new Point(7, -24);
+  const r4 = pt4.normalise();
+  expect(Math.sqrt(r4.x ** 2 + r4.y ** 2)).toBeCloseTo(1);
+
+  // Zero vector: returns (0, 0) rather than NaN
+  const pt5 = new Point(0, 0);
+  const r5 = pt5.normalise();
+  expect(r5.x).toBe(0);
+  expect(r5.y).toBe(0);
+});
+
+test('Test Point.scale', () => {
+  // Scale by positive factor
+  const pt1 = new Point(3, 4);
+  const r1 = pt1.scale(2);
+  expect(r1.x).toBeCloseTo(6);
+  expect(r1.y).toBeCloseTo(8);
+
+  // Scale by fractional factor
+  const pt2 = new Point(10, -5);
+  const r2 = pt2.scale(0.5);
+  expect(r2.x).toBeCloseTo(5);
+  expect(r2.y).toBeCloseTo(-2.5);
+
+  // Scale by zero → origin
+  const pt3 = new Point(7, -3);
+  const r3 = pt3.scale(0);
+  expect(r3.x).toBeCloseTo(0);
+  expect(r3.y).toBeCloseTo(0);
+
+  // Scale by negative factor
+  const pt4 = new Point(1, 2);
+  const r4 = pt4.scale(-3);
+  expect(r4.x).toBeCloseTo(-3);
+  expect(r4.y).toBeCloseTo(-6);
+});
+
+test('Test Point.scaleFrom', () => {
+  const base = new Point();
+
+  // Scale by 2 from origin
+  const pt1 = new Point(5, 0);
+  const r1 = pt1.scaleFrom(base, 2);
+  expect(r1.x).toBeCloseTo(10);
+  expect(r1.y).toBeCloseTo(0);
+
+  // Scale by 0.5 from origin
+  const pt2 = new Point(0, 10);
+  const r2 = pt2.scaleFrom(base, 0.5);
+  expect(r2.x).toBeCloseTo(0);
+  expect(r2.y).toBeCloseTo(5);
+
+  // Scale by 1 leaves point unchanged
+  const pt3 = new Point(3, 7);
+  const r3 = pt3.scaleFrom(base, 1);
+  expect(r3.x).toBeCloseTo(3);
+  expect(r3.y).toBeCloseTo(7);
+
+  // Scale from an offset base point
+  const offsetBase = new Point(10, 10);
+  const pt4 = new Point(20, 10);
+  const r4 = pt4.scaleFrom(offsetBase, 2);
+  expect(r4.x).toBeCloseTo(30);
+  expect(r4.y).toBeCloseTo(10);
+
+  // Scale by 0 collapses point onto base
+  const pt5 = new Point(5, 5);
+  const r5 = pt5.scaleFrom(offsetBase, 0);
+  expect(r5.x).toBeCloseTo(10);
+  expect(r5.y).toBeCloseTo(10);
+
+  // Preserves bulge and sequence
+  const pt6 = new Point(4, 0, 0.5, 10);
+  const r6 = pt6.scaleFrom(base, 2);
+  expect(r6.x).toBeCloseTo(8);
+  expect(r6.y).toBeCloseTo(0);
+  expect(r6.bulge).toBe(0.5);
+  expect(r6.sequence).toBe(10);
+});
+
 test('Test Point.min', () => {
   const pt1 = new Point(10, 10);
 
@@ -195,17 +372,17 @@ test('Test Point.project', () => {
   expect(project1.y).toBe(0);
 
   /* 45 degrees */
-  const project2 = pt1.project(Math.PI/4, 10);
+  const project2 = pt1.project(Math.PI / 4, 10);
   expect(project2.x).toBeCloseTo(7.07);
   expect(project2.y).toBeCloseTo(7.07);
 
   /* 90 degrees */
-  const project3 = pt1.project(Math.PI/2, 10);
+  const project3 = pt1.project(Math.PI / 2, 10);
   expect(project3.x).toBeCloseTo(0);
   expect(project3.y).toBeCloseTo(10);
 
   /* -90 degrees */
-  const project4 = pt1.project(-Math.PI/2, 10);
+  const project4 = pt1.project(-Math.PI / 2, 10);
   expect(project4.x).toBeCloseTo(0);
   expect(project4.y).toBeCloseTo(-10);
 
@@ -215,13 +392,13 @@ test('Test Point.project', () => {
   expect(project5.y).toBeCloseTo(0);
 
   /* 270 degrees */
-  const project6 = pt1.project(Math.PI*1.5, 10);
+  const project6 = pt1.project(Math.PI * 1.5, 10);
   expect(project6.x).toBeCloseTo(0);
   expect(project6.y).toBeCloseTo(-10);
 
   const pt2 = new Point(100, 100);
   /* Non-zero 45 degrees */
-  const project7 = pt2.project(Math.PI/4, 100);
+  const project7 = pt2.project(Math.PI / 4, 100);
   expect(project7.x).toBeCloseTo(170.710);
   expect(project7.y).toBeCloseTo(170.710);
 });
@@ -285,48 +462,177 @@ test('Test Point.closestPointOnLine', () => {
 
   const pt4 = new Point(15, 15);
   const perp4 = pt4.closestPointOnLine(lineStart1, lineEnd1);
-  expect(perp4).toBe(null);
+  expect(perp4).toBe(lineEnd1);
 });
 
 test('Test Point.closestPointOnArc', () => {
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
+  // clockwise 270 degrees 45 - 135
+  // direction: ccw > 0, cw <= 0
+  let arc = { centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10) };
 
-  const pt3 = new Point(5, 5);
-  const closest1 = pt3.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre);
-  expect(closest1.x).toBe(10);
-  expect(closest1.y).toBe(10);
+  let point = new Point(5, 5);
+  let closest = point.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre);
+  expect(closest.x).toBe(10);
+  expect(closest.y).toBe(10);
 
-  const pt4 = new Point(0, 5);
-  const closest2 = pt4.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre);
-  expect(closest2.x).toBe(0);
-  expect(closest2.y).toBeCloseTo(14.14);
+  point = new Point(0, 5);
+  closest = point.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre);
+  expect(closest).toBe(null);
 
-  const pt5 = new Point(20, 10);
-  const closest3 = pt5.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre);
-  expect(closest3).toBe(null);
+  point = new Point(20, 10);
+  closest = point.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre, 0);
+  expect(closest.x).toBeCloseTo(12.649);
+  expect(closest.y).toBeCloseTo(6.3245);
 
   // test circle i.e. start and end points are the same
-  const pt6 = new Point(5, 5);
-  const onCircle = pt6.closestPointOnArc(arc.startPoint, arc.startPoint, arc.centre);
+  point = new Point(5, 5);
+  const onCircle = point.closestPointOnArc(arc.startPoint, arc.startPoint, arc.centre);
   expect(onCircle.x).toBe(10);
   expect(onCircle.y).toBe(10);
+
+
+  // counter clockwise 90 degrees 45 - 135
+  // direction: ccw > 0, cw <= 0
+  arc = { centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10), direction: 1 };
+
+  point = new Point(5, 5);
+  closest = point.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(closest.x).toBe(10);
+  expect(closest.y).toBe(10);
+
+  point = new Point(0, 10);
+  closest = point.closestPointOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(closest.x).toBeCloseTo(0);
+  expect(closest.y).toBeCloseTo(14.14);
 });
 
 
 test('Test Point.isOnArc', () => {
-  const arc = {centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10)};
+  // clockwise arc 270: 45 - 135
+  // direction: ccw > 0, cw <= 0
+  let arc = { centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10) };
 
-  const pt3 = new Point(5, 5);
-  const onArc1 = pt3.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
-  expect(onArc1).toBe(true);
+  let point = new Point(5, 5);
+  let onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
+  expect(onArc).toBe(true);
 
-  const pt4 = new Point(0, 5);
-  const onArc2 = pt4.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
-  expect(onArc2).toBe(true);
+  point = new Point(0, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
+  expect(onArc).toBe(false);
 
-  const pt5 = new Point(20, 10);
-  const onArc3 = pt5.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
-  expect(onArc3).toBe(false);
+  point = new Point(20, 10);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
+  expect(onArc).toBe(true);
+
+  point = new Point(0, 14.14);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre);
+  expect(onArc).toBe(false);
+
+
+  // clockwise arc 90 degrees: 45 - 135
+  // direction: ccw > 0, cw <= 0
+  arc = { centre: new Point(), radius: 14.14, startPoint: new Point(10, 10), endPoint: new Point(-10, 10), direction: 1 };
+
+  point = new Point(5, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(0, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(20, 10);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+  point = new Point(0, 14.14);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  // counter clockwise arc 270 degrees: 135 - 45
+  // direction: ccw > 0, cw <= 0
+  arc = { centre: new Point(), radius: 14.14, startPoint: new Point(-10, 10), endPoint: new Point(10, 10), direction: 1 };
+
+  point = new Point(5, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(0, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+  point = new Point(20, 10);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(0, 14.14);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+
+  // clockwise arc 180 degrees: 180 - 0
+  // direction: ccw > 0, cw <= 0
+  arc = { centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(10, 0), direction: 0 };
+
+
+  point = new Point(5, 0);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(-5, 0);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(5, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(0, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(-5, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(5, -5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+  // Counter clockwise arc 180 degrees: 180 - 0
+  // direction: ccw > 0, cw <= 0
+  arc = { centre: new Point(), radius: 14.14, startPoint: new Point(-10, 0), endPoint: new Point(10, 0), direction: 1 };
+
+  point = new Point(5, 0);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(-5, 0);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  point = new Point(5, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+  point = new Point(0, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+  point = new Point(-5, 5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(false);
+
+  point = new Point(5, -5);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
+
+  // clockwise arc 180 degrees: 180 - 0
+  // direction: ccw > 0, cw <= 0
+  arc = { centre: new Point(0, 5), radius: 5, startPoint: new Point(-5, 5), endPoint: new Point(5, 5), direction: -1 };
+  point = new Point(5, 7);
+  onArc = point.isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction);
+  expect(onArc).toBe(true);
 });
 
 test('Test Point.isOnLine', () => {
@@ -350,6 +656,38 @@ test('Test Point.isOnLine', () => {
   expect(isOnLine4).toBe(false);
 });
 
+
+test('Test Point.isInRectangle', () => {
+  let pt = new Point(5, 5);
+  const bl = new Point(0, 0);
+  const br = new Point(10, 0);
+  const tr = new Point(10, 10);
+  const tl = new Point(0, 10);
+
+  const isInRect = pt.isInRectangle(bl, br, tr, tl);
+  expect(isInRect).toBe(true);
+
+  // not in rectangle
+  pt = new Point(-5, 5);
+  const notInRect = pt.isInRectangle(bl, br, tr, tl);
+  expect(notInRect).toBe(false);
+
+  // on edge of rectangle
+  pt = new Point(0, 0);
+  const onEdgeRect = pt.isInRectangle(bl, br, tr, tl);
+  expect(onEdgeRect).toBe(true);
+
+  // rotated rectangle
+  pt = new Point(0, 5);
+  const bl2 = new Point(0, 0);
+  const br2 = new Point(7, 7);
+  const tr2 = new Point(0, 10);
+  const tl2 = new Point(-7, 7);
+  const isInRotatedRect = pt.isInRectangle(bl2, br2, tr2, tl2);
+  expect(isInRotatedRect).toBe(true);
+});
+
+
 test('Test Point.bulgeAngle', () => {
   const angle = Math.PI;
   const bulge = Math.tan(angle / 4);

package/test/entities/solid.test.js

@@ -0,0 +1,156 @@
+import { Solid } from '../../core/entities/solid.js';
+import { Point } from '../../core/entities/point.js';
+
+import { File } from '../test-helpers/test-helpers.js';
+
+
+test('Test Solid.boundingBox', () => {
+  const solid = new Solid({ points: [new Point(100, 100), new Point(200, 100), new Point(200, 200)] });
+  expect(solid.boundingBox().xMin).toBeCloseTo(100);
+  expect(solid.boundingBox().xMax).toBeCloseTo(200);
+  expect(solid.boundingBox().yMin).toBeCloseTo(100);
+  expect(solid.boundingBox().yMax).toBeCloseTo(200);
+});
+
+
+test('Test Solid.dxf', () => {
+  // test solid with 3 points
+  const solid = new Solid({ handle: '1', points: [new Point(100, 100), new Point(200, 100), new Point(200, 200)] });
+  let file = new File();
+  solid.dxf(file);
+  // console.log(file.contents);
+
+  const dxfString = `0
+SOLID
+5
+1
+100
+AcDbEntity
+100
+AcDbTrace
+8
+0
+10
+100
+20
+100
+30
+0.0
+11
+200
+21
+100
+31
+0.0
+12
+200
+22
+200
+32
+0.0
+13
+200
+23
+200
+33
+0.0
+`;
+
+  expect(file.contents).toEqual(dxfString);
+
+  // create new entity from entity data to ensure all props are loaded
+  const newSolid = new Solid(solid);
+  file = new File();
+  newSolid.dxf(file);
+  expect(file.contents).toEqual(dxfString);
+
+  // test solid with 4 points
+  const solid2 = new Solid({ handle: '1', points: [new Point(100, 100), new Point(200, 100), new Point(200, 200), new Point(300, 300)] });
+  const file2 = new File();
+  solid2.dxf(file2);
+  // console.log(file.contents);
+
+  const dxfString2 = `0
+SOLID
+5
+1
+100
+AcDbEntity
+100
+AcDbTrace
+8
+0
+10
+100
+20
+100
+30
+0.0
+11
+200
+21
+100
+31
+0.0
+12
+200
+22
+200
+32
+0.0
+13
+300
+23
+300
+33
+0.0
+`;
+
+  expect(file2.contents).toEqual(dxfString2);
+});
+
+
+test('Solid.closestPoint returns input point and Infinity', () => {
+  const solid = new Solid({ points: [new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(0, 1)] });
+  const testPoint = new Point(5, 5);
+  const [closest, dist] = solid.closestPoint(testPoint);
+  expect(closest).toBe(testPoint);
+  expect(dist).toBe(Infinity);
+});
+
+test('Solid.toPolylinePoints returns correct points array', () => {
+  const pts = [new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(0, 1)];
+  const solid = new Solid({ points: pts });
+  const result = solid.toPolylinePoints();
+  expect(result.length).toBe(5);
+  expect(result[0].x).toBe(0);
+  expect(result[0].y).toBe(0);
+  expect(result[4].x).toBe(0);
+  expect(result[4].y).toBe(0);
+});
+
+test('Test Solid.toPolylinePoints', () => {
+  const solid = new Solid({ points: [new Point(100, 100), new Point(200, 100), new Point(200, 200)] });
+  const solidPoints = solid.toPolylinePoints();
+  expect(solidPoints.length).toBe(4);
+  expect(solidPoints[0].x).toBe(100);
+  expect(solidPoints[0].y).toBe(100);
+  expect(solidPoints[0].bulge).toBe(0);
+  expect(solidPoints[1].x).toBe(200);
+  expect(solidPoints[1].y).toBe(100);
+  expect(solidPoints[2].x).toBe(200);
+  expect(solidPoints[2].y).toBe(200);
+  // closing point matches first point
+  expect(solidPoints[3].x).toBe(100);
+  expect(solidPoints[3].y).toBe(100);
+});
+
+test('Test Solid.toPolylinePoints with 4 points', () => {
+  const solid = new Solid({ points: [new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(0, 1)] });
+  const solidPoints = solid.toPolylinePoints();
+  expect(solidPoints.length).toBe(5);
+  expect(solidPoints[4].x).toBe(0);
+  expect(solidPoints[4].y).toBe(0);
+});
+
+