mirror of
https://github.com/whscullin/apple2js.git
synced 2024-01-12 14:14:38 +00:00
715ea6ffaa
Like the DOS 3.3 sector order issues in #49, this change fixes the order of the physical sectors on the ProDOS disk when nibblized. This change also adds tests similar to the DOS 3.3 tests to verify the sector order. Because the DOS 3.3 and ProDOS tests are so similar, the utility methods have been refactored into their own file.
287 lines
10 KiB
TypeScript
287 lines
10 KiB
TypeScript
import DOS from '../../../js/formats/do';
|
|
import { memory } from '../../../js/types';
|
|
import { BYTES_BY_SECTOR, BYTES_BY_TRACK } from './testdata/16sector';
|
|
import { expectSequence, findBytes, skipGap } from './util';
|
|
|
|
describe('DOS format', () => {
|
|
it('is callable', () => {
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
expect(disk).not.toBeNull();
|
|
});
|
|
|
|
it('has correct number of tracks', () => {
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
expect(disk.tracks.length).toEqual(35);
|
|
});
|
|
|
|
it('has correct number of bytes in track 0', () => {
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
expect(disk.tracks[0].length).toEqual(6632);
|
|
});
|
|
|
|
it('has correct number of bytes in all tracks', () => {
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
// Track 0 is slightly longer for some reason.
|
|
expect(disk.tracks[0].length).toEqual(6632);
|
|
for (let i = 1; i < disk.tracks.length; i++) {
|
|
expect(disk.tracks[i].length).toEqual(6602);
|
|
}
|
|
});
|
|
|
|
it('has correct GAP 1', () => {
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
// From Beneith Apple DOS, GAP 1 should have 12-85 0xFF bytes
|
|
const track = disk.tracks[0];
|
|
let numFF = 0;
|
|
while (track[numFF] == 0xFF && numFF < 0x100) {
|
|
numFF++;
|
|
}
|
|
expect(numFF).toBeGreaterThanOrEqual(40);
|
|
expect(numFF).toBeLessThanOrEqual(128);
|
|
});
|
|
|
|
it('has correct Address Field for track 0, sector 0', () => {
|
|
// _Beneath Apple DOS_, TRACK FORMATTING, p. 3-12
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
const track = disk.tracks[0];
|
|
let i = skipGap(track);
|
|
// prologue
|
|
i = expectSequence(track, i, [0xD5, 0xAA, 0x96]);
|
|
// volume 10 = 0b00001010
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// track 0 = 0b00000000
|
|
expect(track[i++]).toBe(0b10101010);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// sector 0 = 0b00000000
|
|
expect(track[i++]).toBe(0b10101010);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// checksum = 0b00000101
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
});
|
|
|
|
it('has correct Data Field for track 0, sector 0 (BYTES_BY_TRACK)', () => {
|
|
// _Beneath Apple DOS_, DATA FIELD ENCODING, pp. 3-13 to 3-21
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
const track: memory = disk.tracks[0];
|
|
// skip to the first address epilogue
|
|
let i = findBytes(track, [0xDE, 0xAA, 0xEB]);
|
|
expect(i).toBeGreaterThan(50);
|
|
i = skipGap(track, i);
|
|
// prologue
|
|
i = expectSequence(track, i, [0xD5, 0xAA, 0xAD]);
|
|
// data (all zeros, which is 0x96 with 6 and 2 encoding)
|
|
for (let j = 0; j < 342; j++) {
|
|
expect(track[i++]).toBe(0x96);
|
|
}
|
|
// checksum (also zero)
|
|
expect(track[i++]).toBe(0x96);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
});
|
|
|
|
it('has correct Address Field for track 0, sector 1', () => {
|
|
// _Beneath Apple DOS_, TRACK FORMATTING, p. 3-12
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
const track = disk.tracks[0];
|
|
// first sector prologue
|
|
let i = findBytes(track, [0xD5, 0xAA, 0x96]);
|
|
|
|
// second sector prologue
|
|
i = findBytes(track, [0xD5, 0xAA, 0x96], i);
|
|
// volume 10 = 0b00001010
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// track 0 = 0b00000000
|
|
expect(track[i++]).toBe(0b10101010);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// sector 1 = 0b00000001
|
|
expect(track[i++]).toBe(0b10101010);
|
|
expect(track[i++]).toBe(0b10101011);
|
|
// checksum = 0b00000101
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101011);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
});
|
|
|
|
it('has correct Data Field for track 0, sector 1 (BYTES_BY_SECTOR)', () => {
|
|
// _Beneath Apple DOS_, DATA FIELD ENCODING, pp. 3-13 to 3-21
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_SECTOR,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
const track: memory = disk.tracks[0];
|
|
// First data field prologue
|
|
let i = findBytes(track, [0xD5, 0xAA, 0xAD]);
|
|
// Second data field prologue
|
|
i = findBytes(track, [0xD5, 0xAA, 0xAD], i);
|
|
// Sector 1 is DOS sector 7.
|
|
// In 6 x 2 encoding, the lowest 2 bits of all the bytes come first.
|
|
// 0x07 is 0b00000111, so the lowest two bits are 0b11, reversed and
|
|
// repeated would be 0b111111 (3F -> 0xFF), but since each byte is
|
|
// XOR'd with the previous, this means there are 85 0b00000000 (00 ->
|
|
// 0x96) bytes.
|
|
expect(track[i++]).toBe(0xFF);
|
|
for (let j = 0; j < 85; j++) {
|
|
expect(track[i++]).toBe(0x96);
|
|
}
|
|
// Next we get 256 instances of the top bits, 0b000001. Again, with
|
|
// the XOR, this means one 0b000001 XOR 0b111111 = 0b111110
|
|
// (3E -> 0xFE) followed by 255 0b0000000 (00 -> 0x96).
|
|
expect(track[i++]).toBe(0xFE);
|
|
for (let j = 0; j < 255; j++) {
|
|
expect(track[i++]).toBe(0x96);
|
|
}
|
|
// checksum
|
|
expect(track[i++]).toBe(0x97);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
});
|
|
|
|
it('has correct Address Field for track 1, sector 0', () => {
|
|
// _Beneath Apple DOS_, TRACK FORMATTING, p. 3-12
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
const track = disk.tracks[1];
|
|
let i = skipGap(track);
|
|
// prologue
|
|
i = expectSequence(track, i, [0xD5, 0xAA, 0x96]);
|
|
// volume 10 = 0b00001010
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// track 1 = 0b00000001
|
|
expect(track[i++]).toBe(0b10101010);
|
|
expect(track[i++]).toBe(0b10101011);
|
|
// sector 0 = 0b00000000
|
|
expect(track[i++]).toBe(0b10101010);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// checksum = 0b00000100
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101011);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
});
|
|
|
|
it('has correct Data Field for track 1, sector 0 (BYTES_BY_TRACK)', () => {
|
|
// _Beneath Apple DOS_, DATA FIELD ENCODING, pp. 3-13 to 3-21
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
const track: memory = disk.tracks[1];
|
|
let i = findBytes(track, [0xDE, 0xAA, 0xEB]);
|
|
expect(i).toBeGreaterThan(50);
|
|
i = skipGap(track, i);
|
|
// prologue
|
|
i = expectSequence(track, i, [0xD5, 0xAA, 0xAD]);
|
|
// In 6 x 2 encoding, the lowest 2 bits of all the bytes come first.
|
|
// This would normally mean 86 instances of 0b101010 (2A -> 0xE6),
|
|
// but each byte is XOR'd with the previous. Since all of the bits
|
|
// are the same, this means there are 85 0b000000 (00 -> 0x96).
|
|
expect(track[i++]).toBe(0xE6);
|
|
for (let j = 0; j < 85; j++) {
|
|
expect(track[i++]).toBe(0x96);
|
|
}
|
|
// Next we get 256 instances of the top bits, 0b000000. Again, with
|
|
// the XOR, this means one 0x101010 (2A -> 0xE6) followed by 255
|
|
// 0b0000000 (00 -> 0x96).
|
|
expect(track[i++]).toBe(0xE6);
|
|
for (let j = 0; j < 255; j++) {
|
|
expect(track[i++]).toBe(0x96);
|
|
}
|
|
// checksum (also zero)
|
|
expect(track[i++]).toBe(0x96);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
});
|
|
|
|
it('has correct Address Fields for all tracks', () => {
|
|
// _Beneath Apple DOS_, TRACK FORMATTING, p. 3-12
|
|
const disk = DOS({
|
|
name: 'test disk',
|
|
data: BYTES_BY_TRACK,
|
|
volume: 10,
|
|
readOnly: true,
|
|
});
|
|
|
|
for (let t = 0; t < disk.tracks.length; t++) {
|
|
// We essentially seek through the track for the Address Fields
|
|
const track = disk.tracks[t];
|
|
let i = findBytes(track, [0xD5, 0xAA, 0x96]);
|
|
for (let s = 0; s <= 15; s++) {
|
|
// volume 10 = 0b00001010
|
|
expect(track[i++]).toBe(0b10101111);
|
|
expect(track[i++]).toBe(0b10101010);
|
|
// convert track to 4x4 encoding
|
|
const track4x4XX = ((t & 0b10101010) >> 1) | 0b10101010;
|
|
const track4x4YY = (t & 0b01010101) | 0b10101010;
|
|
expect(track[i++]).toBe(track4x4XX);
|
|
expect(track[i++]).toBe(track4x4YY);
|
|
// convert sector to 4x4 encoding
|
|
const sector4x4XX = ((s & 0b10101010) >> 1) | 0b10101010;
|
|
const sector4x4YY = (s & 0b01010101) | 0b10101010;
|
|
expect(track[i++]).toBe(sector4x4XX);
|
|
expect(track[i++]).toBe(sector4x4YY);
|
|
// checksum
|
|
expect(track[i++]).toBe(0b10101111 ^ track4x4XX ^ sector4x4XX);
|
|
expect(track[i++]).toBe(0b10101010 ^ track4x4YY ^ sector4x4YY);
|
|
// epilogue
|
|
i = expectSequence(track, i, [0xDE, 0xAA, 0xEB]);
|
|
// next sector
|
|
i = findBytes(track, [0xD5, 0xAA, 0x96], i);
|
|
}
|
|
}
|
|
});
|
|
}); |