ihex: Remove assumption that records have 16 bytes in data fields.

Author: microbit-carlos

src/__tests__/hex-files/.gitignore

@@ -0,0 +1 @@
+test-output-*.hex

src/__tests__/hex-files/1-duck-umbrella.hex renamed to src/__tests__/hex-files/1-duck-umbrella-16.hex

@@ -57,9 +57,16 @@ describe('Test createRecord() for standard records', () => {
   // TODO: Add tests for the StartLinearAddress record
 
   it('Throws error when data given is too large', () => {
+    let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    data = data.concat(data);
     expect(() => {
-      const d = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
-      ihex.createRecord(0, ihex.RecordType.Data, new Uint8Array(d));
+      ihex.createRecord(0, ihex.RecordType.Data, new Uint8Array(data));
+    }).not.toThrow();
+
+    data.push(33);
+
+    expect(() => {
+      ihex.createRecord(0, ihex.RecordType.Data, new Uint8Array(data));
     }).toThrow();
   });
 
@@ -336,14 +343,12 @@ describe('Test blockEndRecord()', () => {
 
   it('Throws error when the number of bytes to pad is too large', () => {
     expect(() => {
-      ihex.blockEndRecord(17);
-    }).toThrow('has too many bytes');
-  });
-});
+      ihex.blockEndRecord(32);
+    }).not.toThrow('has too many bytes');
 
-describe('Test recordPaddingCapacity()', () => {
-  it('Check return value is 0x10', () => {
-    expect(ihex.recordPaddingCapacity()).toEqual(16);
+    expect(() => {
+      ihex.blockEndRecord(33);
+    }).toThrow('has too many bytes');
   });
 });
 
@@ -365,7 +370,11 @@ describe('Test paddedDataRecord()', () => {
 
   it('Throws error when the number of bytes to pad is too large', () => {
     expect(() => {
-      ihex.paddedDataRecord(17);
+      ihex.paddedDataRecord(32);
+    }).not.toThrow('has too many bytes');
+
+    expect(() => {
+      ihex.paddedDataRecord(33);
     }).toThrow('has too many bytes');
   });
 });

src/__tests__/hex-files/1-duck-umbrella-32.hex

@@ -3,11 +3,11 @@ import * as fs from 'fs';
 import * as uh from '../universal-hex';
 
 const hex1 = fs.readFileSync(
-  './src/__tests__/hex-files/1-duck-umbrella.hex',
+  './src/__tests__/hex-files/1-duck-umbrella-16.hex',
   'utf8'
 );
 const hex2 = fs.readFileSync(
-  './src/__tests__/hex-files/2-ghost-music.hex',
+  './src/__tests__/hex-files/2-ghost-music-16.hex',
   'utf8'
 );
 
@@ -375,30 +375,58 @@ describe('Test createUniversalHex()', () => {
 
   /*
   // Not real unit tests, just converting files for manual testing
-  const hex1 = fs.readFileSync(
-    './src/__tests__/hex-files/1-duck-umbrella.hex',
+  const hex1_32 = fs.readFileSync(
+    './src/__tests__/hex-files/1-duck-umbrella-32.hex',
     'utf8'
   );
-  const hex2 = fs.readFileSync(
-    './src/__tests__/hex-files/2-ghost-music.hex',
+  const hex2_32 = fs.readFileSync(
+    './src/__tests__/hex-files/2-ghost-music-32.hex',
     'utf8'
   );
 
-  it('.', () => {
-    const result1 = uh.iHexToCustomFormat(hex1, 0x9901);
-    fs.writeFileSync('./src/__tests__/hex-files/test-output-1.hex', result1);
-    const result2 = uh.iHexToCustomFormat(hex2, 0x9903);
-    fs.writeFileSync('./src/__tests__/hex-files/test-output-2.hex', result2);
+  it('Creates Universal Hex files for a single target', () => {
+    const result1_16 = uh.iHexToCustomFormat(hex1, 0x9901);
+    fs.writeFileSync(
+      './src/__tests__/hex-files/test-output-1-16.hex',
+      result1_16
+    );
+    const result2_16 = uh.iHexToCustomFormat(hex2, 0x9903);
+    fs.writeFileSync(
+      './src/__tests__/hex-files/test-output-2-16.hex',
+      result2_16
+    );
+    const result1_32 = uh.iHexToCustomFormat(hex1_32, 0x9901);
+    fs.writeFileSync(
+      './src/__tests__/hex-files/test-output-1-32.hex',
+      result1_32
+    );
+    const result2_32 = uh.iHexToCustomFormat(hex2_32, 0x9903);
+    fs.writeFileSync(
+      './src/__tests__/hex-files/test-output-2-32.hex',
+      result2_32
+    );
 
     expect('').toEqual('');
   });
 
-  it('..', () => {
+  it('Creates a combined universal hex file for both targets', () => {
     const result = uh.createUniversalHex([
-      { hex: hex1, boardID: 0x9901 },
-      { hex: hex2, boardID: 0x9903 },
+      { hex: hex1, boardId: 0x9900 },
+      { hex: hex2, boardId: 0x9903 },
     ]);
-    fs.writeFileSync('./src/__tests__/hex-files/test-output-universal.hex', result);
+    fs.writeFileSync(
+      './src/__tests__/hex-files/test-output-universal-16.hex',
+      result
+    );
+
+    const result32 = uh.createUniversalHex([
+      { hex: hex1_32, boardId: 0x9900 },
+      { hex: hex2_32, boardId: 0x9903 },
+    ]);
+    fs.writeFileSync(
+      './src/__tests__/hex-files/test-output-universal-32.hex',
+      result32
+    );
 
     expect('').toEqual('');
   });

src/__tests__/hex-files/2-ghost-music.hex renamed to src/__tests__/hex-files/2-ghost-music-16.hex

@@ -30,9 +30,9 @@ interface Record {
 
 /**
  * The maximum data bytes per record is 0xFF, 16 and 32 bytes are the two most
- * common lengths, but to start we'll only support 16 bytes
+ * common lengths, but DAPLink doesn't support more than 32 bytes.
  */
-const RECORD_DATA_MAX_BYTES = 16;
+const RECORD_DATA_MAX_BYTES = 32;
 
 /**
  * Constants for the record character lengths.
@@ -318,16 +318,6 @@ function blockEndRecord(padBytesLen: number): string {
   }
 }
 
-/**
- * The Block end record can add bytes to the data field to be generate 512 byte
- * blocks. This function exposes how many bytes the record can fit.
- *
- * @returns Number of padding bytes that fit inside a Block End (custom) Record.
- */
-function recordPaddingCapacity(): number {
-  return RECORD_DATA_MAX_BYTES;
-}
-
 /**
  * Create a Padded Data (custom) Intel Hex Record.
  * This record is used to add padding data, to be ignored by DAPLink, to be able
@@ -380,7 +370,42 @@ function iHexToRecordStrs(iHexStr: string): string[] {
   return output.filter(Boolean);
 }
 
+/**
+ * Iterates through the beginning of an array of Intel Hex records to find the
+ * longest record data field length.
+ *
+ * Once it finds 10 records at the maximum size found so far (starts at 16
+ * bytes) it will stop iterating.
+ *
+ * This is useful to identify the expected max size of the data records for an
+ * Intel Hex, and then be able to generate new custom records of the same size.
+ *
+ * @param iHexRecords Array of Intel Hex Records
+ * @returns Number of data bytes th
+ */
+function findDataFieldLength(iHexRecords: string[]): number {
+  let maxDataBytes = 16;
+  let maxDataBytesCount = 0;
+  for (const record of iHexRecords) {
+    const dataBytesLength = (record.length - MIN_RECORD_STR_LEN) / 2;
+    if (dataBytesLength > maxDataBytes) {
+      maxDataBytes = dataBytesLength;
+      maxDataBytesCount = 0;
+    } else if (dataBytesLength === maxDataBytes) {
+      maxDataBytesCount++;
+    }
+    if (maxDataBytesCount > 10) {
+      break;
+    }
+  }
+  if (maxDataBytes > RECORD_DATA_MAX_BYTES) {
+    throw new Error(`Intel Hex record data size is too large: ${maxDataBytes}`);
+  }
+  return maxDataBytes;
+}
+
 export {
+  MAX_RECORD_STR_LEN,
   RecordType,
   createRecord,
   getRecordType,
@@ -391,7 +416,7 @@ export {
   blockStartRecord,
   blockEndRecord,
   paddedDataRecord,
-  recordPaddingCapacity,
   convertRecordTo,
   iHexToRecordStrs,
+  findDataFieldLength,
 };

src/__tests__/hex-files/2-ghost-music-32.hex

@@ -16,7 +16,7 @@ interface IndividualHex {
 }
 
 /**
- * Converts a hex file string into a Universal Hex ready hex string using custom
+ * Converts an Intel Hex file string into a Universal Hex ready hex string using custom
  * records and 512 byte blocks.
  *
  * Block format:
@@ -43,10 +43,10 @@ function iHexToCustomFormat(iHexStr: string, boardId: number): string {
   const extAddrRecordLen = currentExtAddr.length;
   const startRecordLen = startRecord.length;
   const endRecordBaseLen = ihex.blockEndRecord(0).length;
-  const recordPaddingCapacity = ihex.recordPaddingCapacity();
   const padRecordBaseLen = ihex.paddedDataRecord(0).length;
 
   const hexRecords = ihex.iHexToRecordStrs(iHexStr);
+  const recordPaddingCapacity = ihex.findDataFieldLength(hexRecords);
 
   // Each loop iteration corresponds to a 512-bytes block
   let ih = 0;
@@ -164,16 +164,16 @@ function createUniversalHex(hexes: IndividualHex[]): string {
  */
 function isUniversalHex(hexStr: string): boolean {
   // Check the beginning of the Extended Linear Address record
-  const startOfElaRecord = ':02000004';
-  if (hexStr.slice(0, startOfElaRecord.length) !== startOfElaRecord) {
+  const elaRecordBeginning = ':02000004';
+  if (hexStr.slice(0, elaRecordBeginning.length) !== elaRecordBeginning) {
     return false;
   }
   // Find the index for the next record, as we have unknown line endings
-  let i = startOfElaRecord.length;
-  while (hexStr[++i] !== ':' && i < 50);
+  let i = elaRecordBeginning.length;
+  while (hexStr[++i] !== ':' && i < ihex.MAX_RECORD_STR_LEN + 3);
   // Check the beginning of the Block Start record
-  const startOfBsRecord = ':0400000A';
-  if (hexStr.slice(i, i + startOfBsRecord.length) !== startOfBsRecord) {
+  const blockStartBeginning = ':0400000A';
+  if (hexStr.slice(i, i + blockStartBeginning.length) !== blockStartBeginning) {
     return false;
   }
   return true;