@design-core/core 0.0.1 → 0.0.3

package/test/lib/colour.test.js

@@ -0,0 +1,114 @@
+
+import { Colour, EntityColour } from '../../core/lib/colour.js';
+
+test('Test Colour', () => {
+  const colour = new Colour();
+  expect(colour.aci).toEqual(7);
+  expect(colour.rgb).toEqual({ 'b': 254, 'g': 254, 'r': 254 });
+
+  const colour4 = new Colour(4);
+  expect(colour4.aci).toEqual(4);
+  expect(colour4.rgb).toEqual({ 'b': 255, 'g': 255, 'r': 0 });
+});
+
+test('Test Colour.isTrueColour', () => {
+  const colour = new Colour();
+  expect(colour.isTrueColour).toEqual(false);
+
+  const trueColour = new Colour();
+  trueColour.setColour({ r: 200, g: 100, b: 50 });
+  expect(trueColour.isTrueColour).toEqual(true);
+});
+
+test('Test Colour.getColour', () => {
+  const colour = new Colour();
+  expect(colour.getColour()).toEqual({ 'b': 254, 'g': 254, 'r': 254 });
+});
+
+
+test('Test Colour.setColour', () => {
+  const colour = new Colour();
+  colour.setColour({ r: 200, g: 100, b: 50 });
+  expect(colour.rgb).toEqual({ 'r': 200, 'g': 100, 'b': 50 });
+  expect(colour.aci).toEqual(7);
+
+  colour.setColour({ r: 0, g: 255, b: 255 });
+  expect(colour.rgb).toEqual({ 'r': 0, 'g': 255, 'b': 255 });
+  expect(colour.aci).toEqual(4);
+
+  colour.setColour({ r: 1, g: 2, b: 3 });
+  expect(colour.rgb).toEqual({ 'r': 1, 'g': 2, 'b': 3 });
+  expect(colour.aci).toEqual(7);
+
+  colour.setColour({ r: 1000, g: 2000, b: 3000 });
+  expect(colour.rgb).toEqual({ 'r': 1, 'g': 2, 'b': 3 });
+  expect(colour.aci).toEqual(7);
+});
+
+test('Test Colour.setColourFromACI', () => {
+  const colour = new Colour();
+  colour.setColourFromACI(7);
+  expect(colour.rgb).toEqual({ 'r': 254, 'g': 254, 'b': 254 });
+  expect(colour.aci).toEqual(7);
+
+  colour.setColourFromACI(50);
+  expect(colour.rgb).toEqual({ 'r': 254, 'g': 254, 'b': 0 });
+  expect(colour.aci).toEqual(50);
+
+  colour.setColourFromACI(-1);
+  expect(colour.rgb).toEqual({ 'r': 254, 'g': 254, 'b': 0 });
+  expect(colour.aci).toEqual(50);
+});
+
+/*
+  Entity Colour - Included byblock and bylayer
+*/
+test('Test EntityColour.setColour', () => {
+  const colour = new EntityColour();
+
+  expect(colour.byLayer).toEqual(true);
+  expect(colour.byBlock).toEqual(false);
+
+  colour.setColour({ r: 200, g: 100, b: 50 });
+  expect(colour.rgb).toEqual({ 'r': 200, 'g': 100, 'b': 50 });
+  expect(colour.aci).toEqual(7);
+  expect(colour.byLayer).toEqual(false);
+  expect(colour.byBlock).toEqual(false);
+
+  colour.setColour({ r: 0, g: 0, b: 0 });
+  expect(colour.rgb).toEqual({ 'r': 0, 'g': 0, 'b': 0 });
+  expect(colour.aci).toEqual(0);
+  expect(colour.byLayer).toEqual(false);
+  expect(colour.byBlock).toEqual(true);
+
+  colour.setColour('BYLAYER');
+  expect(colour.aci).toEqual(256);
+  expect(colour.byLayer).toEqual(true);
+  expect(colour.byBlock).toEqual(false);
+
+  colour.setColour('BYBLOCK');
+  expect(colour.aci).toEqual(0);
+  expect(colour.byLayer).toEqual(false);
+  expect(colour.byBlock).toEqual(true);
+
+  colour.setColour('bylayer');
+  expect(colour.aci).toEqual(256);
+  expect(colour.byLayer).toEqual(true);
+  expect(colour.byBlock).toEqual(false);
+
+  colour.setColour('byblock');
+  expect(colour.aci).toEqual(0);
+  expect(colour.byLayer).toEqual(false);
+  expect(colour.byBlock).toEqual(true);
+});
+
+
+test('Colour Conversion Test', () => {
+  const colour = new EntityColour();
+
+  // Check the returned ACI is the same as the set ACI
+  for (let i = 0; i < 255; i++) {
+    colour.setColourFromACI(i);
+    expect(colour.aci).toEqual(i);
+  }
+});

package/test/lib/colours.test.js

@@ -1,29 +1,74 @@
 
-import {Colours} from '../../core/lib/colours.js';
+import { Colours } from '../../core/lib/colours.js';
 
-test('Test Colours.getHexColour', () => {
-  expect(Colours.getHexColour(0)).toBe('BYBLOCK');
-  expect(Colours.getHexColour(255)).toBe('#FFFFFF');
+test('Test Colours.isRGB', () => {
+  expect(Colours.isRGB({ r: 255, g: 255, b: 255 })).toEqual(true);
+  expect(Colours.isRGB({ r: 255, b: 255 })).toEqual(false);
 });
 
-test('Test Colours.getACADColour', () => {
-  expect(Colours.getACADColour('#FF0000')).toBe('1');
-  expect(Colours.getACADColour('#00FF3F')).toBe('100');
+test('Test Colours.aciToRGB', () => {
+  expect(Colours.aciToRGB(0)).toEqual({ r: 0, g: 0, b: 0 });
+  expect(Colours.aciToRGB(255)).toEqual({ r: 255, g: 255, b: 255 });
+
+  // aci 7 should change colour depending on the background colour
+  expect(Colours.aciToRGB(255)).toEqual({ r: 255, g: 255, b: 255 });
+});
+
+test('Test Colours.rgbToACI', () => {
+  expect(Colours.rgbToACI({ r: 0, g: 0, b: 0 })).toEqual(0);
+  expect(Colours.rgbToACI({ r: 254, g: 254, b: 254 })).toEqual(7);
+});
+
+test('Test Colours.rgbToString', () => {
+  expect(Colours.rgbToString({ r: 0, g: 0, b: 0 })).toEqual('rgb(0, 0, 0)');
+  expect(Colours.rgbToString({ r: 255, g: 255, b: 255 })).toEqual('rgb(255, 255, 255)');
+});
+
+test('Test Colours.rgbToScaledRGB', () => {
+  expect(Colours.rgbToScaledRGB({ r: 255, g: 255, b: 255 })).toEqual({ r: 1, g: 1, b: 1 });
+  expect(Colours.rgbToScaledRGB({ r: 100, g: 100, b: 100 })).toEqual({ r: 100 / 255, g: 100 / 255, b: 100 / 255 });
+  expect(Colours.rgbToScaledRGB({ r: 1, g: 1 })).toBeUndefined();
+  expect(Colours.rgbToScaledRGB({})).toBeUndefined();
+});
+
+test('Test Colours.trueColourToRGB', () => {
+  // rgb(200, 100,50)
+  // hex 0x00C86432
+  // int 13132850
+  const rgb = Colours.trueColourToRGB(13132850);
+  expect(rgb.r).toBe(200);
+  expect(rgb.g).toBe(100);
+  expect(rgb.b).toBe(50);
+
+  expect(Colours.trueColourToRGB()).toBeUndefined();
 });
 
-test('Test Colours.rgbToHex', () => {
-  expect(Colours.rgbToHex(1, 1, 1)).toBe('#010101');
-  expect(Colours.rgbToHex(100, 100, 100)).toBe('#646464');
+
+test('Test Colours.rgbToTrueColour', () => {
+  // rgb(200, 100,50)
+  // hex 0x00C86432
+  // int 13132850
+  expect(Colours.rgbToTrueColour({ r: 200, g: 100, b: 50 })).toBe(13132850);
+  expect(Colours.rgbToTrueColour()).toBeUndefined();
 });
 
-test('Test Colours.hexToRGB', () => {
-  expect(Colours.hexToRGB('#010101')).toEqual({r: 1, g: 1, b: 1});
-  expect(Colours.hexToRGB('#646464')).toEqual({r: 100, g: 100, b: 100});
-  expect(Colours.hexToRGB('12345')).toBe(null);
+test('Test Colour Sequence', () => {
+  // loop through all colour values and check the ACI numbers
+  // ensure the numbers are sequential
+  let index = 0;
+
+  for (const key in Colours.rgb_conversion_table) {
+    if (!isNaN(key)) {
+      expect(parseInt(key)).toBe(index);
+      index++;
+    }
+  }
 });
 
-test('Test Colours.hexToScaledRGB', () => {
-  expect(Colours.hexToScaledRGB('#010101')).toEqual({r: 1/255, g: 1/255, b: 1/255});
-  expect(Colours.hexToScaledRGB('#646464')).toEqual({r: 100/255, g: 100/255, b: 100/255});
-  expect(Colours.hexToScaledRGB('12345')).toBe(null);
+test('Colours Conversion Test', () => {
+  // Check the returned ACI is the same as the set ACI
+  for (let i = 0; i < 255; i++) {
+    const rgb = Colours.aciToRGB(i);
+    expect(Colours.rgbToACI(rgb)).toEqual(i);
+  }
 });

package/test/lib/commandLine.test.js

@@ -1,6 +1,7 @@
-import {Core} from '../../core/core/core.js';
-import {Input, PromptOptions} from '../../core/lib/inputManager.js';
-import {Strings} from '../../core/lib/strings.js';
+import { Core } from '../../core/core/core.js';
+import { Input, PromptOptions } from '../../core/lib/inputManager.js';
+import { Strings } from '../../core/lib/strings.js';
+import { expect, jest } from '@jest/globals';
 
 const core = new Core();
 const commandline = core.commandLine; // new CommandLine();
@@ -16,24 +17,7 @@ test('Test Commandline.setPrompt', () => {
   const testText = 'TestTest';
   commandline.setPrompt(testText);
   expect(commandline.prompt).toBe(`${testText}:`);
-
-  // test setPrompt with default - command should be set to default value
-  const testTextWithDefault = 'TestTest <default>';
-  commandline.setPrompt(testTextWithDefault);
-  expect(commandline.prompt).toBe(`${testTextWithDefault}:`);
-  expect(commandline.command).toBe('default');
-});
-
-test('Test Commandline.parseCommandDefault', () => {
-  const commandDefault = ['<default>'];
-  const defaultValue = commandline.parseCommandDefault(commandDefault);
-  expect(defaultValue).toBe(`default`);
-
-  // only a single default is valid
-  commandDefault.push('<second value>');
-  expect(() => {
-    commandline.parseCommandDefault(commandDefault);
-  }).toThrow();
+  expect(commandline.command).toBe('');
 });
 
 test('Test Commandline.update', () => {
@@ -139,7 +123,7 @@ test('Test CommandLine.parseInput', () => {
   expect(relPoint1.x).toBe(101);
   expect(relPoint1.y).toBe(102);
 
-  core.scene.inputManager.initialiseItem('Line');
+  core.scene.inputManager.startCommand('Line');
   core.scene.inputManager.activeCommand.points.push(relPoint1);
   const relPoint2 = commandline.parseInput('@101,102');
   expect(relPoint2.constructor.name).toBe('Point');
@@ -215,6 +199,159 @@ test('Test CommandLine.addToCommandHistory', () => {
   commandline.lastCommand = [];
 });
 
+test('Test CommandLine.setUpdateFunction registers callback and triggers it', () => {
+  const callback = jest.fn();
+  commandline.setUpdateFunction(callback);
+  expect(callback).toHaveBeenCalled();
+  commandline.setUpdateFunction(undefined);
+});
+
+test('Test CommandLine.escapePressed delegates to inputManager.onEscapePressed', () => {
+  const inputManager = core.scene.inputManager;
+  const spy = jest.spyOn(inputManager, 'onEscapePressed').mockImplementation(() => {});
+  commandline.escapePressed();
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+test('Test CommandLine.deletePressed delegates to inputManager.onCommand with Erase', () => {
+  const inputManager = core.scene.inputManager;
+  const spy = jest.spyOn(inputManager, 'onCommand').mockImplementation(() => {});
+  commandline.deletePressed();
+  expect(spy).toHaveBeenCalledWith('Erase');
+  spy.mockRestore();
+});
+
+test('Test CommandLine.enterPressed with empty command calls onEnterPressed', () => {
+  const inputManager = core.scene.inputManager;
+  commandline.resetPrompt();
+  const spy = jest.spyOn(inputManager, 'onEnterPressed').mockImplementation(() => {});
+  commandline.enterPressed();
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+test('Test CommandLine.enterPressed with command calls onCommand with parsed value', () => {
+  const inputManager = core.scene.inputManager;
+  commandline.resetPrompt();
+  commandline.handleKeys('42');
+  const spy = jest.spyOn(inputManager, 'onCommand').mockImplementation(() => {});
+  commandline.enterPressed();
+  expect(spy).toHaveBeenCalledWith(42);
+  spy.mockRestore();
+  commandline.resetPrompt();
+});
+
+test('Test CommandLine.handleKeys routes Backspace to backPressed', () => {
+  commandline.handleKeys('123');
+  commandline.handleKeys('Backspace');
+  expect(commandline.command).toBe('12');
+  commandline.resetPrompt();
+});
+
+test('Test CommandLine.handleKeys routes Enter to enterPressed', () => {
+  const spy = jest.spyOn(commandline, 'enterPressed').mockImplementation(() => {});
+  commandline.handleKeys('Enter');
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+test('Test CommandLine.handleKeys routes Escape to escapePressed', () => {
+  const spy = jest.spyOn(commandline, 'escapePressed').mockImplementation(() => {});
+  commandline.handleKeys('Escape');
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+test('Test CommandLine.handleKeys routes Space to spacePressed', () => {
+  const spy = jest.spyOn(commandline, 'spacePressed').mockImplementation(() => {});
+  commandline.handleKeys('Space');
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+test('Test CommandLine.handleKeys routes Delete to deletePressed', () => {
+  const spy = jest.spyOn(commandline, 'deletePressed').mockImplementation(() => {});
+  commandline.handleKeys('Delete');
+  expect(spy).toHaveBeenCalled();
+  spy.mockRestore();
+});
+
+test('Test CommandLine.handleKeys routes Up-Arrow to previousCommand up', () => {
+  const spy = jest.spyOn(commandline, 'previousCommand').mockImplementation(() => {});
+  commandline.handleKeys('Up-Arrow');
+  expect(spy).toHaveBeenCalledWith('up');
+  spy.mockRestore();
+});
+
+test('Test CommandLine.handleKeys routes Down-Arrow to previousCommand down', () => {
+  const spy = jest.spyOn(commandline, 'previousCommand').mockImplementation(() => {});
+  commandline.handleKeys('Down-Arrow');
+  expect(spy).toHaveBeenCalledWith('down');
+  spy.mockRestore();
+});
+
+test('Test CommandLine.handleKeys with undefined key does not change command', () => {
+  commandline.resetPrompt();
+  commandline.handleKeys(undefined);
+  expect(commandline.command).toBe('');
+});
+
+test('Test CommandLine.previousCommand cycles up through history', () => {
+  commandline.lastCommand = ['Circle', 'Line', 'Rect'];
+  commandline.lastCommandPosition = -1;
+
+  commandline.previousCommand('up');
+  expect(commandline.command).toBe('Circle');
+  expect(commandline.lastCommandPosition).toBe(0);
+
+  commandline.previousCommand('up');
+  expect(commandline.command).toBe('Line');
+  expect(commandline.lastCommandPosition).toBe(1);
+
+  commandline.previousCommand('up');
+  expect(commandline.command).toBe('Rect');
+  expect(commandline.lastCommandPosition).toBe(2);
+
+  // At end of history - stays at last entry
+  commandline.previousCommand('up');
+  expect(commandline.command).toBe('Rect');
+  expect(commandline.lastCommandPosition).toBe(2);
+
+  commandline.lastCommand = [];
+  commandline.resetPrompt();
+});
+
+test('Test CommandLine.previousCommand cycles down through history', () => {
+  commandline.lastCommand = ['Circle', 'Line', 'Rect'];
+  commandline.lastCommandPosition = 2;
+  commandline.command = 'Rect';
+
+  commandline.previousCommand('down');
+  expect(commandline.command).toBe('Line');
+  expect(commandline.lastCommandPosition).toBe(1);
+
+  commandline.previousCommand('down');
+  expect(commandline.command).toBe('Circle');
+  expect(commandline.lastCommandPosition).toBe(0);
+
+  // At position 0 going down resets the prompt
+  commandline.previousCommand('down');
+  expect(commandline.command).toBe('');
+  expect(commandline.lastCommandPosition).toBe(-1);
+
+  commandline.lastCommand = [];
+});
+
+test('Test CommandLine.previousCommand up with empty history is a no-op', () => {
+  commandline.lastCommand = [];
+  commandline.lastCommandPosition = -1;
+  commandline.command = '';
+  commandline.previousCommand('up');
+  expect(commandline.command).toBe('');
+  expect(commandline.lastCommandPosition).toBe(-1);
+});
+
 test('Test CommandLine.addToCommandHistory', () => {
   commandline.addToCommandHistory('3');
   commandline.addToCommandHistory('2');

package/test/lib/commandManager.test.js

@@ -1,6 +1,6 @@
 
-import {Core} from '../../core/core/core.js';
-import {Point} from '../../core/entities/point.js';
+import { Core } from '../../core/core/core.js';
+import { Point } from '../../core/entities/point.js';
 
 const core = new Core();
 const commandManager = core.commandManager;
@@ -10,10 +10,10 @@ test('Test CommandManager.createNew', () => {
   const endPoint = new Point(10, 10);
   const points = [startPoint, endPoint];
 
-  const line = commandManager.createNew('Line', {points: points});
+  const line = commandManager.createNew('Line', { points: points });
   expect(typeof line).toBe('object');
 
-  const test = commandManager.createNew('test', {points: points});
+  const test = commandManager.createNew('test', { points: points });
   expect(typeof test).toBe('undefined');
 });
 

package/test/lib/constants.test.js

@@ -0,0 +1,9 @@
+import { Constants } from '../../core/lib/constants.js';
+
+test('Constants.Tolerance.EPSILON is 1e-10', () => {
+  expect(Constants.Tolerance.EPSILON).toBe(1e-10);
+});
+
+test('Constants.Precision.DECIMALPLACES is 5', () => {
+  expect(Constants.Precision.DECIMALPLACES).toBe(5);
+});

package/test/lib/dxf/dxfFile.test.js

@@ -1,4 +1,4 @@
-import {DXFFile} from '../../../core/lib/dxf/dxfFile.js';
+import { DXFFile } from '../../../core/lib/dxf/dxfFile.js';
 
 const file = new DXFFile();
 
@@ -15,8 +15,12 @@ test('Test DXFFile.writeGroupCode', () => {
   file.writeGroupCode('groupCode', 'groupValue');
 
   const output = 'groupCode\ngroupValue\n';
-
   expect(file.contents).toEqual(output);
+
+  // throw on undefined values
+  expect(() => {
+    file.writeGroupCode('groupCode', undefined);
+  }).toThrow();
 });
 
 test('Test DXFFile.clearFile', () => {

package/test/lib/dxf/dxfIterator.test.js

@@ -1,4 +1,4 @@
-import {DxfIterator} from '../../../core/lib/dxf/dxfIterator.js';
+import { DxfIterator } from '../../../core/lib/dxf/dxfIterator.js';
 
 const iterator = new DxfIterator();
 const string = '1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n0\nEOF';

package/test/lib/dxf/dxfWrite.test.js

@@ -0,0 +1,173 @@
+import { DXFWriter } from '../../../core/lib/dxf/dxfWrite.js';
+import { DXFFile } from '../../../core/lib/dxf/dxfFile.js';
+import { DesignCore } from '../../../core/designCore.js';
+import { jest } from '@jest/globals';
+
+const createManager = (styleName = 'default') => ({
+  items: [],
+  getCstyle: jest.fn(() => styleName),
+  dxf: jest.fn(),
+});
+
+const createCoreMock = (options = {}) => {
+  const blocks = options.blocks || [];
+  const entities = options.entities || [];
+
+  return {
+    dxfVersion: options.dxfVersion || 'R2018',
+    handleManager: { next() {
+      return '1';
+    }, get handseed() {
+      return '1';
+    } },
+    layerManager: options.layerManager || createManager('Layer0'),
+    ltypeManager: options.ltypeManager || createManager('Continuous'),
+    styleManager: options.styleManager || createManager('Standard'),
+    dimStyleManager: options.dimStyleManager || createManager('ISO-25'),
+    viewManager: options.viewManager || { dxf: jest.fn() },
+    vportManager: options.vportManager || { dxf: jest.fn() },
+    ucsManager: options.ucsManager || { dxf: jest.fn() },
+    appIdManager: options.appIdManager || { dxf: jest.fn() },
+    blockRecordManager: options.blockRecordManager || { dxf: jest.fn() },
+    dictionaryManager: options.dictionaryManager || { dxf: jest.fn() },
+    scene: {
+      dxf: jest.fn(),
+      headers: { dxf: jest.fn(), dxfVersion: options.dxfVersion || 'R2018' },
+      entities: {
+        count: jest.fn(() => entities.length),
+        get: jest.fn((index) => entities[index]),
+      },
+      blockManager: {
+        items: blocks,
+      },
+    },
+  };
+};
+
+describe('DXFWriter', () => {
+  let originalCore;
+
+  beforeAll(() => {
+    originalCore = DesignCore._core;
+  });
+
+  afterAll(() => {
+    DesignCore.Core = originalCore;
+  });
+
+  test('Test DXFWriter.writeHeaders', () => {
+    const core = createCoreMock({
+      entities: [{}, {}],
+      blocks: [{ name: 'BlockA' }, { name: 'BlockB' }],
+    });
+
+    core.layerManager.items = [{}, {}, {}];
+    core.ltypeManager.items = [{}, {}, {}, {}];
+    core.styleManager.items = [{}, {}, {}, {}, {}];
+    core.dimStyleManager.items = [{}, {}, {}, {}, {}, {}];
+
+    DesignCore.Core = core;
+
+    const writer = new DXFWriter();
+    const file = new DXFFile('R2018');
+    writer.writeHeaders(file);
+
+    expect(file.contents).toContain('0\nSECTION\n2\nHEADER\n');
+    expect(core.scene.headers.dxf).toHaveBeenCalledWith(file);
+    expect(file.contents).toContain('0\nENDSEC\n');
+  });
+
+  test('Test DXFWriter.writeTables', () => {
+    const core = createCoreMock({
+      blocks: [{ name: 'BlockOne' }, { name: 'BlockTwo' }],
+    });
+    DesignCore.Core = core;
+
+    const writer = new DXFWriter();
+    const file = new DXFFile('R2018');
+    writer.writeTables(file);
+
+    expect(core.ltypeManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.layerManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.styleManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.dimStyleManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.vportManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.viewManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.ucsManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.appIdManager.dxf).toHaveBeenCalledWith(file);
+    expect(core.blockRecordManager.dxf).toHaveBeenCalledWith(file);
+
+    expect(file.contents).toContain('0\nSECTION\n2\nTABLES\n');
+    expect(file.contents).toContain('0\nENDSEC\n');
+  });
+
+  test('Test DXFWriter.writeBlocks', () => {
+    const blockA = { dxf: jest.fn() };
+    const blockB = { dxf: jest.fn() };
+    const core = createCoreMock({
+      blocks: [blockA, blockB],
+    });
+    DesignCore.Core = core;
+
+    const writer = new DXFWriter();
+    const file = new DXFFile('R2018');
+    writer.writeBlocks(file);
+
+    expect(blockA.dxf).toHaveBeenCalledWith(file);
+    expect(blockB.dxf).toHaveBeenCalledWith(file);
+    expect(file.contents).toContain('0\nSECTION\n2\nBLOCKS\n');
+    expect(file.contents).toContain('0\nENDSEC\n');
+  });
+
+  test('Test DXFWriter.writeEntities', () => {
+    const entityA = { dxf: jest.fn() };
+    const entityB = { dxf: jest.fn() };
+    const core = createCoreMock({
+      entities: [entityA, entityB],
+    });
+    DesignCore.Core = core;
+
+    const writer = new DXFWriter();
+    const file = new DXFFile('R2018');
+    writer.writeEntities(file);
+
+    expect(entityA.dxf).toHaveBeenCalledWith(file);
+    expect(entityB.dxf).toHaveBeenCalledWith(file);
+    expect(file.contents).toContain('0\nSECTION\n2\nENTITIES\n');
+    expect(file.contents).toContain('0\nENDSEC\n');
+  });
+
+  test('Test DXFWriter.write default version from core', () => {
+    const core = createCoreMock({
+      dxfVersion: 'R12',
+    });
+    DesignCore.Core = core;
+
+    const writer = new DXFWriter();
+    const output = writer.write();
+
+    expect(output).toContain('999\nDXF created from Design-Core\n');
+    expect(output).toContain('2\nHEADER\n');
+    expect(output).toContain('2\nTABLES\n');
+    expect(output).toContain('2\nBLOCKS\n');
+    expect(output).toContain('2\nENTITIES\n');
+    expect(output).toContain('0\nEOF\n');
+
+    expect(output).not.toContain('2\nOBJECTS\n');
+    expect(output).not.toContain('0\nDICTIONARY\n');
+  });
+
+  test('Test DXFWriter.write supports explicit version', () => {
+    const core = createCoreMock({
+      dxfVersion: 'R12',
+    });
+    DesignCore.Core = core;
+
+    const writer = new DXFWriter();
+    const output = writer.write('R2018');
+
+    expect(output).toContain('2\nOBJECTS\n');
+    expect(core.dictionaryManager.dxf).toHaveBeenCalled();
+    expect(output).toContain('0\nEOF\n');
+  });
+});