595 lines
23 KiB
TypeScript
595 lines
23 KiB
TypeScript
/**
|
|
* Firmware Loader Tests
|
|
*
|
|
* Tests the firmwareLoader.ts utility with:
|
|
* - Unit tests using synthetic data (format detection, ELF parsing, HEX conversion)
|
|
* - Integration tests using real arduino-cli compiled binaries (AVR, RP2040, ESP32-C3)
|
|
* - Cross-format compatibility tests
|
|
* - Simulator loading tests (verify compiled firmware loads without crashing)
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, afterEach, vi, beforeAll } from 'vitest';
|
|
import { readFileSync, existsSync } from 'fs';
|
|
import { join } from 'path';
|
|
import {
|
|
detectFirmwareFormat,
|
|
detectArchitectureFromElf,
|
|
extractLoadSegmentsFromElf,
|
|
binaryToIntelHex,
|
|
readFirmwareFile,
|
|
} from '../utils/firmwareLoader';
|
|
import { hexToUint8Array } from '../utils/hexParser';
|
|
import { AVRSimulator } from '../simulation/AVRSimulator';
|
|
import { PinManager } from '../simulation/PinManager';
|
|
|
|
// ── Mock requestAnimationFrame (not available in Node) ───────────────────────
|
|
beforeEach(() => {
|
|
let counter = 0;
|
|
let depth = 0;
|
|
vi.stubGlobal('requestAnimationFrame', (cb: FrameRequestCallback) => {
|
|
if (depth === 0) {
|
|
depth++;
|
|
cb(0);
|
|
depth--;
|
|
}
|
|
return ++counter;
|
|
});
|
|
vi.stubGlobal('cancelAnimationFrame', vi.fn());
|
|
});
|
|
afterEach(() => vi.unstubAllGlobals());
|
|
|
|
// ── Fixture paths ────────────────────────────────────────────────────────────
|
|
const AVR_FIXTURE_DIR = join(__dirname, 'fixtures/avr-blink');
|
|
const RP2040_FIXTURE_DIR = join(__dirname, 'fixtures/rp2040-blink');
|
|
const ESP32C3_FIXTURE_DIR = join(__dirname, 'fixtures/esp32c3-blink');
|
|
|
|
// ── Helper: create a mock File from bytes ────────────────────────────────────
|
|
function mockFile(name: string, content: Uint8Array | string): File {
|
|
const buf = typeof content === 'string'
|
|
? new TextEncoder().encode(content)
|
|
: content;
|
|
const blob = new Blob([buf]);
|
|
return new File([blob], name);
|
|
}
|
|
|
|
// ── Helper: build a minimal ELF32 header ─────────────────────────────────────
|
|
function buildElf32Header(opts: {
|
|
machine: number;
|
|
littleEndian?: boolean;
|
|
phoff?: number;
|
|
phentsize?: number;
|
|
phnum?: number;
|
|
segments?: { type: number; offset: number; paddr: number; filesz: number }[];
|
|
}): Uint8Array {
|
|
const le = opts.littleEndian ?? true;
|
|
// Minimum ELF32 header = 52 bytes
|
|
const phoff = opts.phoff ?? 52;
|
|
const phentsize = opts.phentsize ?? 32;
|
|
const phnum = opts.phnum ?? (opts.segments?.length ?? 0);
|
|
const segData = opts.segments ?? [];
|
|
|
|
const totalSize = phoff + phnum * phentsize + segData.reduce((s, seg) => s + seg.filesz, 0);
|
|
const buf = new ArrayBuffer(Math.max(totalSize, 52 + phnum * phentsize + 256));
|
|
const view = new DataView(buf);
|
|
const arr = new Uint8Array(buf);
|
|
|
|
// ELF magic
|
|
arr[0] = 0x7f; arr[1] = 0x45; arr[2] = 0x4c; arr[3] = 0x46;
|
|
arr[4] = 1; // 32-bit
|
|
arr[5] = le ? 1 : 2; // endianness
|
|
|
|
// e_machine at offset 18
|
|
if (le) {
|
|
view.setUint16(18, opts.machine, true);
|
|
} else {
|
|
view.setUint16(18, opts.machine, false);
|
|
}
|
|
|
|
// e_phoff at offset 28
|
|
view.setUint32(28, phoff, le);
|
|
// e_phentsize at offset 42
|
|
view.setUint16(42, phentsize, le);
|
|
// e_phnum at offset 44
|
|
view.setUint16(44, phnum, le);
|
|
|
|
// Write program headers
|
|
for (let i = 0; i < segData.length; i++) {
|
|
const off = phoff + i * phentsize;
|
|
const seg = segData[i];
|
|
view.setUint32(off, seg.type, le); // p_type
|
|
view.setUint32(off + 4, seg.offset, le); // p_offset
|
|
view.setUint32(off + 8, 0, le); // p_vaddr (unused)
|
|
view.setUint32(off + 12, seg.paddr, le); // p_paddr
|
|
view.setUint32(off + 16, seg.filesz, le); // p_filesz
|
|
view.setUint32(off + 20, seg.filesz, le); // p_memsz
|
|
|
|
// Write segment data at p_offset
|
|
for (let j = 0; j < seg.filesz; j++) {
|
|
arr[seg.offset + j] = (j + 1) & 0xff; // fill with predictable data
|
|
}
|
|
}
|
|
|
|
return new Uint8Array(buf, 0, Math.max(totalSize, 52));
|
|
}
|
|
|
|
// ═════════════════════════════════════════════════════════════════════════════
|
|
// Part 1: Unit tests — synthetic data, no arduino-cli needed
|
|
// ═════════════════════════════════════════════════════════════════════════════
|
|
|
|
describe('firmwareLoader — format detection', () => {
|
|
it('detects Intel HEX by magic byte (colon)', () => {
|
|
const hex = new TextEncoder().encode(':00000001FF\n');
|
|
expect(detectFirmwareFormat('firmware', hex)).toBe('hex');
|
|
});
|
|
|
|
it('detects Intel HEX by .hex extension', () => {
|
|
const data = new Uint8Array([0x00, 0x01, 0x02]);
|
|
expect(detectFirmwareFormat('blink.hex', data)).toBe('hex');
|
|
});
|
|
|
|
it('detects Intel HEX by .ihex extension', () => {
|
|
const data = new Uint8Array([0x00, 0x01, 0x02]);
|
|
expect(detectFirmwareFormat('firmware.ihex', data)).toBe('hex');
|
|
});
|
|
|
|
it('detects ELF by magic bytes', () => {
|
|
const elf = new Uint8Array([0x7f, 0x45, 0x4c, 0x46, 0x01, 0x01, 0x00, 0x00]);
|
|
expect(detectFirmwareFormat('firmware', elf)).toBe('elf');
|
|
});
|
|
|
|
it('detects ELF by .elf extension', () => {
|
|
const data = new Uint8Array([0x00, 0x01, 0x02]);
|
|
expect(detectFirmwareFormat('blink.elf', data)).toBe('elf');
|
|
});
|
|
|
|
it('defaults to bin for unknown formats', () => {
|
|
const data = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
|
|
expect(detectFirmwareFormat('firmware.bin', data)).toBe('bin');
|
|
expect(detectFirmwareFormat('unknown_file', data)).toBe('bin');
|
|
});
|
|
|
|
it('ELF magic takes priority over extension', () => {
|
|
const elf = new Uint8Array([0x7f, 0x45, 0x4c, 0x46, 0x01, 0x01]);
|
|
expect(detectFirmwareFormat('firmware.bin', elf)).toBe('elf');
|
|
});
|
|
});
|
|
|
|
describe('firmwareLoader — ELF architecture detection', () => {
|
|
it('detects AVR (e_machine=0x53)', () => {
|
|
const elf = buildElf32Header({ machine: 0x53 });
|
|
const info = detectArchitectureFromElf(elf);
|
|
expect(info).not.toBeNull();
|
|
expect(info!.architectureName).toBe('AVR');
|
|
expect(info!.suggestedBoard).toBe('arduino-uno');
|
|
expect(info!.is32bit).toBe(true);
|
|
expect(info!.isLittleEndian).toBe(true);
|
|
});
|
|
|
|
it('detects ARM (e_machine=0x28)', () => {
|
|
const elf = buildElf32Header({ machine: 0x28 });
|
|
const info = detectArchitectureFromElf(elf);
|
|
expect(info!.architectureName).toBe('ARM');
|
|
expect(info!.suggestedBoard).toBe('raspberry-pi-pico');
|
|
});
|
|
|
|
it('detects RISC-V (e_machine=0xF3)', () => {
|
|
const elf = buildElf32Header({ machine: 0xf3 });
|
|
const info = detectArchitectureFromElf(elf);
|
|
expect(info!.architectureName).toBe('RISC-V');
|
|
expect(info!.suggestedBoard).toBe('esp32-c3');
|
|
});
|
|
|
|
it('detects Xtensa (e_machine=0x5E)', () => {
|
|
const elf = buildElf32Header({ machine: 0x5e });
|
|
const info = detectArchitectureFromElf(elf);
|
|
expect(info!.architectureName).toBe('Xtensa');
|
|
expect(info!.suggestedBoard).toBe('esp32');
|
|
});
|
|
|
|
it('returns Unknown for unrecognized machine type', () => {
|
|
const elf = buildElf32Header({ machine: 0x99 });
|
|
const info = detectArchitectureFromElf(elf);
|
|
expect(info!.architectureName).toBe('Unknown');
|
|
expect(info!.suggestedBoard).toBeNull();
|
|
});
|
|
|
|
it('returns null for non-ELF data', () => {
|
|
const data = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
|
|
expect(detectArchitectureFromElf(data)).toBeNull();
|
|
});
|
|
|
|
it('returns null for data too short', () => {
|
|
const data = new Uint8Array([0x7f, 0x45]);
|
|
expect(detectArchitectureFromElf(data)).toBeNull();
|
|
});
|
|
|
|
it('handles big-endian ELF', () => {
|
|
const elf = buildElf32Header({ machine: 0x53, littleEndian: false });
|
|
const info = detectArchitectureFromElf(elf);
|
|
expect(info!.isLittleEndian).toBe(false);
|
|
expect(info!.architectureName).toBe('AVR');
|
|
});
|
|
});
|
|
|
|
describe('firmwareLoader — binaryToIntelHex round-trip', () => {
|
|
it('converts 10 bytes and round-trips through hexParser', () => {
|
|
const original = new Uint8Array([0x0F, 0xEF, 0x04, 0xB9, 0x00, 0xE2, 0x05, 0xB9, 0xFF, 0xCF]);
|
|
const hex = binaryToIntelHex(original);
|
|
|
|
// Should start with ':'
|
|
expect(hex.startsWith(':')).toBe(true);
|
|
// Should end with EOF record
|
|
expect(hex.endsWith(':00000001FF')).toBe(true);
|
|
|
|
// Parse back
|
|
const parsed = hexToUint8Array(hex);
|
|
expect(parsed.length).toBeGreaterThanOrEqual(original.length);
|
|
for (let i = 0; i < original.length; i++) {
|
|
expect(parsed[i]).toBe(original[i]);
|
|
}
|
|
});
|
|
|
|
it('handles empty data', () => {
|
|
const hex = binaryToIntelHex(new Uint8Array(0));
|
|
expect(hex).toBe(':00000001FF');
|
|
});
|
|
|
|
it('handles data larger than 16 bytes (multiple lines)', () => {
|
|
const data = new Uint8Array(48);
|
|
for (let i = 0; i < 48; i++) data[i] = i;
|
|
const hex = binaryToIntelHex(data);
|
|
const lines = hex.split('\n');
|
|
|
|
// 48 bytes / 16 per line = 3 data lines + 1 EOF
|
|
expect(lines.length).toBe(4);
|
|
expect(lines[3]).toBe(':00000001FF');
|
|
|
|
// Round-trip
|
|
const parsed = hexToUint8Array(hex);
|
|
for (let i = 0; i < 48; i++) {
|
|
expect(parsed[i]).toBe(data[i]);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('firmwareLoader — extractLoadSegmentsFromElf', () => {
|
|
it('extracts PT_LOAD segments from synthetic ELF', () => {
|
|
const dataOffset = 52 + 32; // header + 1 program header
|
|
const elf = buildElf32Header({
|
|
machine: 0x53,
|
|
segments: [
|
|
{ type: 1 /* PT_LOAD */, offset: dataOffset, paddr: 0x0000, filesz: 16 },
|
|
],
|
|
});
|
|
const result = extractLoadSegmentsFromElf(elf);
|
|
expect(result.length).toBe(16);
|
|
// Verify data matches what buildElf32Header wrote
|
|
for (let i = 0; i < 16; i++) {
|
|
expect(result[i]).toBe((i + 1) & 0xff);
|
|
}
|
|
});
|
|
|
|
it('extracts multiple PT_LOAD segments and sorts by address', () => {
|
|
const seg1Offset = 52 + 64; // after 2 program headers
|
|
const seg2Offset = seg1Offset + 8;
|
|
const elf = buildElf32Header({
|
|
machine: 0x28,
|
|
segments: [
|
|
{ type: 1, offset: seg2Offset, paddr: 0x1000, filesz: 8 }, // higher addr first
|
|
{ type: 1, offset: seg1Offset, paddr: 0x0000, filesz: 8 }, // lower addr second
|
|
],
|
|
});
|
|
const result = extractLoadSegmentsFromElf(elf);
|
|
// Should include gap between 0x0000+8 and 0x1000+8
|
|
expect(result.length).toBe(0x1000 + 8);
|
|
});
|
|
|
|
it('skips non-PT_LOAD segments', () => {
|
|
const dataOffset = 52 + 64;
|
|
const elf = buildElf32Header({
|
|
machine: 0x53,
|
|
segments: [
|
|
{ type: 2 /* PT_DYNAMIC */, offset: dataOffset, paddr: 0x0000, filesz: 16 },
|
|
{ type: 1 /* PT_LOAD */, offset: dataOffset + 16, paddr: 0x0000, filesz: 8 },
|
|
],
|
|
});
|
|
const result = extractLoadSegmentsFromElf(elf);
|
|
expect(result.length).toBe(8);
|
|
});
|
|
|
|
it('throws on ELF with no program headers', () => {
|
|
const elf = buildElf32Header({ machine: 0x53, phoff: 0, phnum: 0 });
|
|
expect(() => extractLoadSegmentsFromElf(elf)).toThrow('no program headers');
|
|
});
|
|
|
|
it('parses existing ESP32-C3 blink.elf fixture', () => {
|
|
const elfPath = join(ESP32C3_FIXTURE_DIR, 'blink.elf');
|
|
if (!existsSync(elfPath)) return; // skip if fixture missing
|
|
const elfData = new Uint8Array(readFileSync(elfPath));
|
|
|
|
const info = detectArchitectureFromElf(elfData);
|
|
expect(info).not.toBeNull();
|
|
expect(info!.architectureName).toBe('RISC-V');
|
|
|
|
const segments = extractLoadSegmentsFromElf(elfData);
|
|
expect(segments.length).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════════════════════════════
|
|
// Part 2: Integration tests — real arduino-cli compiled binaries
|
|
// ═════════════════════════════════════════════════════════════════════════════
|
|
|
|
describe('firmwareLoader — AVR integration (arduino-cli)', () => {
|
|
let avrHexData: Uint8Array | null = null;
|
|
let avrElfData: Uint8Array | null = null;
|
|
|
|
beforeAll(() => {
|
|
const hexPath = join(AVR_FIXTURE_DIR, 'avr-blink.ino.hex');
|
|
const elfPath = join(AVR_FIXTURE_DIR, 'avr-blink.ino.elf');
|
|
|
|
if (existsSync(hexPath)) avrHexData = new Uint8Array(readFileSync(hexPath));
|
|
if (existsSync(elfPath)) avrElfData = new Uint8Array(readFileSync(elfPath));
|
|
});
|
|
|
|
it('compiled .hex fixture exists and is valid Intel HEX', () => {
|
|
if (!avrHexData) return; // skip if not compiled
|
|
expect(avrHexData.length).toBeGreaterThan(0);
|
|
// First byte should be ':' (0x3A)
|
|
expect(avrHexData[0]).toBe(0x3a);
|
|
// Should be parseable
|
|
const text = new TextDecoder().decode(avrHexData);
|
|
const bytes = hexToUint8Array(text);
|
|
expect(bytes.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('compiled .elf fixture exists and is detected as AVR', () => {
|
|
if (!avrElfData) return;
|
|
const info = detectArchitectureFromElf(avrElfData);
|
|
expect(info).not.toBeNull();
|
|
expect(info!.architectureName).toBe('AVR');
|
|
expect(info!.suggestedBoard).toBe('arduino-uno');
|
|
expect(info!.is32bit).toBe(true);
|
|
});
|
|
|
|
it('readFirmwareFile loads .hex for AVR board', async () => {
|
|
if (!avrHexData) return;
|
|
const file = mockFile('blink.hex', avrHexData);
|
|
const result = await readFirmwareFile(file, 'arduino-uno');
|
|
|
|
expect(result.format).toBe('hex');
|
|
expect(result.program).toContain(':');
|
|
expect(result.message).toContain('Intel HEX');
|
|
expect(result.elfInfo).toBeNull();
|
|
});
|
|
|
|
it('readFirmwareFile loads .elf for AVR board → converts to HEX', async () => {
|
|
if (!avrElfData) return;
|
|
const file = mockFile('blink.elf', avrElfData);
|
|
const result = await readFirmwareFile(file, 'arduino-uno');
|
|
|
|
expect(result.format).toBe('elf');
|
|
expect(result.program).toContain(':'); // Should be Intel HEX text
|
|
expect(result.program).toContain(':00000001FF'); // EOF record
|
|
expect(result.elfInfo).not.toBeNull();
|
|
expect(result.elfInfo!.architectureName).toBe('AVR');
|
|
});
|
|
|
|
it('AVRSimulator.loadHex accepts the .hex firmware', () => {
|
|
if (!avrHexData) return;
|
|
const pm = new PinManager();
|
|
const sim = new AVRSimulator(pm);
|
|
const hexText = new TextDecoder().decode(avrHexData);
|
|
|
|
// Should not throw
|
|
expect(() => sim.loadHex(hexText)).not.toThrow();
|
|
});
|
|
|
|
it('AVRSimulator.loadHex accepts ELF-converted HEX', async () => {
|
|
if (!avrElfData) return;
|
|
const file = mockFile('blink.elf', avrElfData);
|
|
const result = await readFirmwareFile(file, 'arduino-uno');
|
|
|
|
const pm = new PinManager();
|
|
const sim = new AVRSimulator(pm);
|
|
|
|
// Should not throw
|
|
expect(() => sim.loadHex(result.program)).not.toThrow();
|
|
});
|
|
|
|
it('AVR blink .hex runs and toggles pin 13 (PORTB bit 5)', () => {
|
|
if (!avrHexData) return;
|
|
const pm = new PinManager();
|
|
const sim = new AVRSimulator(pm);
|
|
const hexText = new TextDecoder().decode(avrHexData);
|
|
sim.loadHex(hexText);
|
|
|
|
// Run some cycles — the blink sketch sets DDRB and PORTB during setup()
|
|
// We can't run the full animation loop, but we can verify the program loaded
|
|
// and the simulator doesn't crash during initial execution
|
|
sim.start();
|
|
sim.stop();
|
|
|
|
// If we got here without throwing, the firmware loaded and executed correctly
|
|
expect(true).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('firmwareLoader — RP2040 integration (arduino-cli)', () => {
|
|
let rp2040BinData: Uint8Array | null = null;
|
|
let rp2040ElfData: Uint8Array | null = null;
|
|
|
|
beforeAll(() => {
|
|
const binPath = join(RP2040_FIXTURE_DIR, 'rp2040-blink.ino.bin');
|
|
const elfPath = join(RP2040_FIXTURE_DIR, 'rp2040-blink.ino.elf');
|
|
|
|
if (existsSync(binPath)) rp2040BinData = new Uint8Array(readFileSync(binPath));
|
|
if (existsSync(elfPath)) rp2040ElfData = new Uint8Array(readFileSync(elfPath));
|
|
});
|
|
|
|
it('compiled .bin fixture exists', () => {
|
|
if (!rp2040BinData) return;
|
|
expect(rp2040BinData.length).toBeGreaterThan(0);
|
|
console.log(`RP2040 .bin size: ${rp2040BinData.length} bytes`);
|
|
});
|
|
|
|
it('compiled .elf fixture is detected as ARM', () => {
|
|
if (!rp2040ElfData) return;
|
|
const info = detectArchitectureFromElf(rp2040ElfData);
|
|
expect(info).not.toBeNull();
|
|
expect(info!.architectureName).toBe('ARM');
|
|
expect(info!.suggestedBoard).toBe('raspberry-pi-pico');
|
|
});
|
|
|
|
it('readFirmwareFile loads .bin for RP2040 board → base64', async () => {
|
|
if (!rp2040BinData) return;
|
|
const file = mockFile('blink.bin', rp2040BinData);
|
|
const result = await readFirmwareFile(file, 'raspberry-pi-pico');
|
|
|
|
expect(result.format).toBe('bin');
|
|
expect(result.message).toContain('binary firmware');
|
|
// Program should be base64 — verify it decodes back to same length
|
|
const decoded = atob(result.program);
|
|
expect(decoded.length).toBe(rp2040BinData.length);
|
|
});
|
|
|
|
it('readFirmwareFile loads .elf for RP2040 board → base64', async () => {
|
|
if (!rp2040ElfData) return;
|
|
const file = mockFile('blink.elf', rp2040ElfData);
|
|
const result = await readFirmwareFile(file, 'raspberry-pi-pico');
|
|
|
|
expect(result.format).toBe('elf');
|
|
expect(result.elfInfo!.architectureName).toBe('ARM');
|
|
// Should produce base64 (not HEX text)
|
|
expect(result.program).not.toContain(':00000001FF');
|
|
const decoded = atob(result.program);
|
|
expect(decoded.length).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
|
|
describe('firmwareLoader — ESP32-C3 integration (fixture)', () => {
|
|
let esp32BinData: Uint8Array | null = null;
|
|
let esp32ElfData: Uint8Array | null = null;
|
|
|
|
beforeAll(() => {
|
|
const binPath = join(ESP32C3_FIXTURE_DIR, 'blink.bin');
|
|
const elfPath = join(ESP32C3_FIXTURE_DIR, 'blink.elf');
|
|
|
|
if (existsSync(binPath)) esp32BinData = new Uint8Array(readFileSync(binPath));
|
|
if (existsSync(elfPath)) esp32ElfData = new Uint8Array(readFileSync(elfPath));
|
|
});
|
|
|
|
it('blink.bin fixture exists', () => {
|
|
if (!esp32BinData) return;
|
|
expect(esp32BinData.length).toBeGreaterThan(0);
|
|
console.log(`ESP32-C3 .bin size: ${esp32BinData.length} bytes`);
|
|
});
|
|
|
|
it('blink.elf fixture detected as RISC-V', () => {
|
|
if (!esp32ElfData) return;
|
|
const info = detectArchitectureFromElf(esp32ElfData);
|
|
expect(info).not.toBeNull();
|
|
expect(info!.architectureName).toBe('RISC-V');
|
|
expect(info!.suggestedBoard).toBe('esp32-c3');
|
|
});
|
|
|
|
it('readFirmwareFile loads .bin for ESP32-C3 board → base64', async () => {
|
|
if (!esp32BinData) return;
|
|
const file = mockFile('blink.bin', esp32BinData);
|
|
const result = await readFirmwareFile(file, 'esp32-c3');
|
|
|
|
expect(result.format).toBe('bin');
|
|
const decoded = atob(result.program);
|
|
expect(decoded.length).toBe(esp32BinData.length);
|
|
});
|
|
|
|
it('readFirmwareFile loads .elf for ESP32-C3 board → base64', async () => {
|
|
if (!esp32ElfData) return;
|
|
const file = mockFile('blink.elf', esp32ElfData);
|
|
const result = await readFirmwareFile(file, 'esp32-c3');
|
|
|
|
expect(result.format).toBe('elf');
|
|
expect(result.elfInfo!.architectureName).toBe('RISC-V');
|
|
// base64 output
|
|
const decoded = atob(result.program);
|
|
expect(decoded.length).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
|
|
// ═════════════════════════════════════════════════════════════════════════════
|
|
// Part 3: Cross-format compatibility tests
|
|
// ═════════════════════════════════════════════════════════════════════════════
|
|
|
|
describe('firmwareLoader — cross-format compatibility', () => {
|
|
let avrHexData: Uint8Array | null = null;
|
|
let rp2040BinData: Uint8Array | null = null;
|
|
let avrElfData: Uint8Array | null = null;
|
|
|
|
beforeAll(() => {
|
|
const hexPath = join(AVR_FIXTURE_DIR, 'avr-blink.ino.hex');
|
|
const binPath = join(RP2040_FIXTURE_DIR, 'rp2040-blink.ino.bin');
|
|
const elfPath = join(AVR_FIXTURE_DIR, 'avr-blink.ino.elf');
|
|
|
|
if (existsSync(hexPath)) avrHexData = new Uint8Array(readFileSync(hexPath));
|
|
if (existsSync(binPath)) rp2040BinData = new Uint8Array(readFileSync(binPath));
|
|
if (existsSync(elfPath)) avrElfData = new Uint8Array(readFileSync(elfPath));
|
|
});
|
|
|
|
it('.hex file loaded for AVR board → returns HEX text', async () => {
|
|
if (!avrHexData) return;
|
|
const file = mockFile('blink.hex', avrHexData);
|
|
const result = await readFirmwareFile(file, 'arduino-uno');
|
|
expect(result.format).toBe('hex');
|
|
expect(result.program).toContain(':');
|
|
});
|
|
|
|
it('.bin file loaded for RP2040 board → returns base64', async () => {
|
|
if (!rp2040BinData) return;
|
|
const file = mockFile('blink.bin', rp2040BinData);
|
|
const result = await readFirmwareFile(file, 'raspberry-pi-pico');
|
|
expect(result.format).toBe('bin');
|
|
// Valid base64
|
|
expect(() => atob(result.program)).not.toThrow();
|
|
});
|
|
|
|
it('.hex file loaded for ESP32-C3 → still works (HEX text passed through)', async () => {
|
|
if (!avrHexData) return;
|
|
const file = mockFile('blink.hex', avrHexData);
|
|
const result = await readFirmwareFile(file, 'esp32-c3');
|
|
// HEX is passed through as text regardless of board
|
|
expect(result.format).toBe('hex');
|
|
expect(result.program).toContain(':');
|
|
});
|
|
|
|
it('AVR .elf loaded for ESP32 board → detects architecture mismatch', async () => {
|
|
if (!avrElfData) return;
|
|
const file = mockFile('blink.elf', avrElfData);
|
|
const result = await readFirmwareFile(file, 'esp32');
|
|
|
|
// Should still load (no error), but elfInfo shows AVR
|
|
expect(result.format).toBe('elf');
|
|
expect(result.elfInfo!.architectureName).toBe('AVR');
|
|
expect(result.elfInfo!.suggestedBoard).toBe('arduino-uno');
|
|
// For ESP32 board, output should be base64 (not HEX)
|
|
expect(result.program).not.toContain(':00000001FF');
|
|
});
|
|
|
|
it('.bin file loaded for AVR board → returns base64 (user responsibility)', async () => {
|
|
if (!rp2040BinData) return;
|
|
const file = mockFile('firmware.bin', rp2040BinData);
|
|
// Should not throw — it's the user's choice
|
|
const result = await readFirmwareFile(file, 'arduino-uno');
|
|
expect(result.format).toBe('bin');
|
|
// Even though board is AVR, .bin returns base64 (compileBoardProgram will route it)
|
|
expect(() => atob(result.program)).not.toThrow();
|
|
});
|
|
|
|
it('rejects files over 16MB', async () => {
|
|
// Create a fake File that reports large size
|
|
const largeFile = new File([new Uint8Array(1)], 'huge.bin');
|
|
Object.defineProperty(largeFile, 'size', { value: 17 * 1024 * 1024 });
|
|
|
|
await expect(readFirmwareFile(largeFile, 'arduino-uno')).rejects.toThrow('too large');
|
|
});
|
|
});
|