572 lines
22 KiB
Dart
572 lines
22 KiB
Dart
import 'dart:typed_data';
|
|
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:openscooter/scooters/apollo_protocol.dart';
|
|
import 'package:openscooter/scooters/scooter.dart';
|
|
|
|
Uint8List hex(String s) => Uint8List.fromList(
|
|
s.trim().split(RegExp(r'\s+')).map((h) => int.parse(h, radix: 16)).toList(),
|
|
);
|
|
|
|
/// Synthetic monitor frame from the brief (section 35). CRC valid.
|
|
final monitorFrame =
|
|
hex('AA 00 00 00 02 4B 00 FA 00 C8 01 E0 01 40 23 28 00 7B 00 30 39 8A 24 E9 1F');
|
|
|
|
/// Synthetic base frame from the brief (section 46). CRC valid.
|
|
final baseFrame =
|
|
hex('AB 01 00 19 06 0C 14 1E 80 00 1F 00 27 10 13 88 00 64 12 AB 02 05 11 F0 C0');
|
|
|
|
/// Re-signs a frame after editing its payload so parser tests only fail on
|
|
/// the field under test, never on CRC.
|
|
Uint8List resign(Uint8List frame) {
|
|
final out = Uint8List.fromList(frame);
|
|
final crc = apolloCrc16(out.sublist(0, out.length - 2));
|
|
out[out.length - 2] = crc & 0xFF;
|
|
out[out.length - 1] = crc >> 8;
|
|
return out;
|
|
}
|
|
|
|
Uint8List patched(Uint8List frame, Map<int, int> bytes) {
|
|
final out = Uint8List.fromList(frame);
|
|
bytes.forEach((i, v) => out[i] = v);
|
|
return resign(out);
|
|
}
|
|
|
|
/// LIVE captures from an Apollo Go, 2026-09-21, idle, full battery,
|
|
/// headlight off. Regression fixtures per brief section 81.
|
|
final realCmd0Idle =
|
|
hex('AA 00 19 01 02 64 00 00 00 00 01 9F 00 00 16 19 00 00 00 0C C5 0E 22 B3 13');
|
|
final realCmd0HeadlightCruise =
|
|
hex('AA 00 19 01 02 64 00 00 00 00 01 9D 00 00 16 19 00 00 00 0C C5 8E 26 2A D7');
|
|
final realCmd0RightSignal =
|
|
hex('AA 00 19 01 02 64 00 00 00 00 01 9E 00 00 16 19 00 00 00 0C C5 2E 2E 57 15');
|
|
final realCmd0LeftSignal =
|
|
hex('AA 00 19 01 02 64 00 00 00 00 01 9E 00 00 16 19 00 00 00 0C C5 4E 36 7F 1F');
|
|
final realCmd1Base =
|
|
hex('AA 01 19 03 0A 0F 1E D8 80 00 1F 00 00 00 00 00 00 00 00 00 00 00 00 68 61');
|
|
|
|
void main() {
|
|
group('real Apollo Go captures', () {
|
|
test('all fixtures are CRC valid', () {
|
|
for (final f in [realCmd0Idle, realCmd0HeadlightCruise, realCmd0RightSignal,
|
|
realCmd0LeftSignal, realCmd1Base]) {
|
|
expect(apolloValidateFrame(f), isTrue, reason: apolloHex(f));
|
|
}
|
|
});
|
|
|
|
test('real cmd1 base frame', () {
|
|
final b = parseApolloBaseFrame(realCmd1Base);
|
|
expect(b.limitCruise, 3);
|
|
expect(b.limitMode1, 10);
|
|
expect(b.limitMode2, 15);
|
|
expect(b.limitMode3, 30);
|
|
expect(b.batteryTemperature, -40);
|
|
expect(b.totalBatteryCapacity, 0);
|
|
expect(b.remainingBatteryCapacity, 0);
|
|
expect(b.batteryCycles, 0);
|
|
expect(b.displayId, isNull);
|
|
expect(b.displayVersion, 'V0.0.0');
|
|
expect(b.faultEnable, isTrue);
|
|
expect([b.ctrlSn, b.ctrlMp3, b.ctrlRgb, b.ctrlBms, b.internalSpeedScalingFlag],
|
|
everyElement(isTrue));
|
|
});
|
|
|
|
test('real cmd0 idle frame with the Go scaling flag', () {
|
|
final m = parseApolloMonitorFrame(realCmd0Idle, internalSpeedScalingFlag: true);
|
|
expect(m.gear, 2);
|
|
expect(m.batteryLevel, 100);
|
|
expect(m.rawSpeed, 0);
|
|
expect(m.speed, 0.0);
|
|
expect(m.voltage, 41.5);
|
|
expect(m.current, 0.0);
|
|
expect(m.power, 0.0);
|
|
expect(m.motorTemperature, 22);
|
|
expect(m.controllerTemperature, 25);
|
|
expect(m.tripDistance, 0.0);
|
|
expect(m.odometer, 326.9);
|
|
expect(m.atmosphereLight, isTrue);
|
|
expect(m.unlocked, isTrue);
|
|
expect(m.headlight, isFalse);
|
|
expect(m.leftTurnSignal, isFalse);
|
|
expect(m.rightTurnSignal, isFalse);
|
|
expect(m.cruiseControl, isFalse);
|
|
expect(m.imperial, isTrue);
|
|
expect(m.bootMode, isFalse);
|
|
});
|
|
|
|
test('real cmd0 variants: headlight+cruise, right signal, left signal', () {
|
|
final h = parseApolloMonitorFrame(realCmd0HeadlightCruise, internalSpeedScalingFlag: true);
|
|
expect(h.headlight, isTrue);
|
|
expect(h.cruiseControl, isTrue);
|
|
expect(h.voltage, 41.3);
|
|
final r = parseApolloMonitorFrame(realCmd0RightSignal, internalSpeedScalingFlag: true);
|
|
expect(r.rightTurnSignal, isTrue);
|
|
expect(r.leftTurnSignal, isFalse);
|
|
final l = parseApolloMonitorFrame(realCmd0LeftSignal, internalSpeedScalingFlag: true);
|
|
expect(l.leftTurnSignal, isTrue);
|
|
expect(l.rightTurnSignal, isFalse);
|
|
});
|
|
|
|
test('real 20 + 5 byte notification split reassembles', () {
|
|
final buf = ApolloFrameBuffer();
|
|
expect(buf.add(realCmd0Idle.sublist(0, 20)), isEmpty);
|
|
expect(buf.add(realCmd0Idle.sublist(20)), [realCmd0Idle]);
|
|
expect(buf.add(realCmd1Base.sublist(0, 20)), isEmpty);
|
|
expect(buf.add(realCmd1Base.sublist(20)), [realCmd1Base]);
|
|
});
|
|
});
|
|
|
|
group('CRC-16', () {
|
|
test('vector 1 from brief', () {
|
|
expect(apolloCrc16(hex('AB 00 0A 00 00 00 00 00')), 0x6A0B);
|
|
});
|
|
test('vector 2 from brief', () {
|
|
expect(apolloCrc16(hex('AB 00 0A 80 19 06 0C 14')), 0xE6E8);
|
|
});
|
|
test('wire order is little-endian and covers header through length-3', () {
|
|
final f = hex('AB 00 0A 00 00 00 00 00 0B 6A');
|
|
expect(apolloValidateFrame(f), isTrue);
|
|
expect(apolloValidateFrame(hex('AB 00 0A 00 00 00 00 00 6A 0B')), isFalse);
|
|
});
|
|
test('synthetic frames validate', () {
|
|
expect(apolloValidateFrame(monitorFrame), isTrue);
|
|
expect(apolloValidateFrame(baseFrame), isTrue);
|
|
});
|
|
test('corrupting one byte fails validation', () {
|
|
final bad = Uint8List.fromList(monitorFrame)..[5] ^= 0x01;
|
|
expect(apolloValidateFrame(bad), isFalse);
|
|
// Including unknown metadata bytes 2 and 3: they are CRC-covered.
|
|
final bad2 = Uint8List.fromList(monitorFrame)..[2] = 0x01;
|
|
expect(apolloValidateFrame(bad2), isFalse);
|
|
});
|
|
test('keepalive constant is not frame-CRC signed', () {
|
|
expect(apolloKeepalivePacket, hex('A5 02 FD 5A'));
|
|
expect(apolloValidateFrame(apolloKeepalivePacket), isFalse);
|
|
});
|
|
});
|
|
|
|
group('PIN command', () {
|
|
test('builds AT+PWD[pin] with no line ending', () {
|
|
expect(String.fromCharCodes(buildApolloPinCommand('123456')), 'AT+PWD[123456]');
|
|
expect(buildApolloPinCommand('123456').last, ']'.codeUnitAt(0));
|
|
});
|
|
test('rejects non six-digit input', () {
|
|
expect(() => buildApolloPinCommand('12345'), throwsArgumentError);
|
|
expect(() => buildApolloPinCommand('12345a'), throwsArgumentError);
|
|
expect(() => buildApolloPinCommand('1234567'), throwsArgumentError);
|
|
});
|
|
});
|
|
|
|
group('PIN response parser', () {
|
|
Uint8List ascii(String s) => Uint8List.fromList(s.codeUnits);
|
|
|
|
test('OK+PWD:Y is success', () {
|
|
expect(parseApolloPinResponse(ascii('OK+PWD:Y')), AuthenticationResult.success);
|
|
});
|
|
test('OK+PWD:N is invalid credential', () {
|
|
expect(parseApolloPinResponse(ascii('OK+PWD:N')), AuthenticationResult.invalidCredential);
|
|
});
|
|
test('search within garbage', () {
|
|
expect(parseApolloPinResponse(ascii('garbageOK+PWD:Y\r\n')), AuthenticationResult.success);
|
|
});
|
|
test('NUL bytes are ignored', () {
|
|
expect(parseApolloPinResponse(ascii('OK+PWD\x00:Y')), AuthenticationResult.success);
|
|
});
|
|
test('partial is null', () {
|
|
expect(parseApolloPinResponse(ascii('OK+PW')), isNull);
|
|
expect(parseApolloPinResponse(ascii('')), isNull);
|
|
});
|
|
test('fragmented response reassembles through the AT buffer', () {
|
|
final buf = ApolloAtBuffer();
|
|
buf.add(ascii('OK+PW'));
|
|
expect(parseApolloPinResponse(buf.bytes), isNull);
|
|
buf.add(ascii('D:Y'));
|
|
expect(parseApolloPinResponse(buf.bytes), AuthenticationResult.success);
|
|
});
|
|
test('AT buffer is capped', () {
|
|
final buf = ApolloAtBuffer(maxLength: 16);
|
|
buf.add(Uint8List.fromList(List.filled(100, 0x41)));
|
|
expect(buf.bytes.length, 16);
|
|
});
|
|
});
|
|
|
|
group('frame lengths', () {
|
|
test('A5 02 is 4, other A5 is 8, AA/AB cmd 0/1 is 25', () {
|
|
expect(apolloFrameLength(0xA5, 0x02), 4);
|
|
expect(apolloFrameLength(0xA5, 0x01), 8);
|
|
expect(apolloFrameLength(0xAA, 0x00), 25);
|
|
expect(apolloFrameLength(0xAA, 0x01), 25);
|
|
expect(apolloFrameLength(0xAB, 0x00), 25);
|
|
expect(apolloFrameLength(0xAB, 0x01), 25);
|
|
expect(apolloFrameLength(0xAB, 0x02), isNull);
|
|
expect(apolloFrameLength(0x00, 0x00), isNull);
|
|
});
|
|
});
|
|
|
|
group('ApolloFrameBuffer', () {
|
|
late ApolloFrameBuffer buf;
|
|
setUp(() => buf = ApolloFrameBuffer());
|
|
|
|
test('one complete frame', () {
|
|
expect(buf.add(monitorFrame), [monitorFrame]);
|
|
expect(buf.length, 0);
|
|
});
|
|
|
|
test('frame split into two chunks', () {
|
|
expect(buf.add(monitorFrame.sublist(0, 10)), isEmpty);
|
|
expect(buf.add(monitorFrame.sublist(10)), [monitorFrame]);
|
|
});
|
|
|
|
test('frame split byte-by-byte', () {
|
|
final out = <Uint8List>[];
|
|
for (final b in monitorFrame) {
|
|
out.addAll(buf.add(Uint8List.fromList([b])));
|
|
}
|
|
expect(out, [monitorFrame]);
|
|
});
|
|
|
|
test('two frames in one notification', () {
|
|
final both = Uint8List.fromList([...monitorFrame, ...baseFrame]);
|
|
expect(buf.add(both), [monitorFrame, baseFrame]);
|
|
});
|
|
|
|
test('one complete plus half of next', () {
|
|
final data = Uint8List.fromList([...monitorFrame, ...baseFrame.sublist(0, 12)]);
|
|
expect(buf.add(data), [monitorFrame]);
|
|
expect(buf.add(baseFrame.sublist(12)), [baseFrame]);
|
|
});
|
|
|
|
test('garbage before a valid frame', () {
|
|
final data = Uint8List.fromList([0x00, 0x11, 0xFF, 0xAA, ...monitorFrame]);
|
|
expect(buf.add(data), [monitorFrame]);
|
|
});
|
|
|
|
test('garbage between valid frames', () {
|
|
final data = Uint8List.fromList([...monitorFrame, 0x13, 0xAB, 0x00, ...baseFrame]);
|
|
expect(buf.add(data), [monitorFrame, baseFrame]);
|
|
});
|
|
|
|
test('bad CRC frame followed by a valid frame', () {
|
|
final bad = Uint8List.fromList(monitorFrame)..[24] ^= 0xFF;
|
|
final data = Uint8List.fromList([...bad, ...baseFrame]);
|
|
expect(buf.add(data), [baseFrame]);
|
|
});
|
|
|
|
test('unsupported head byte and unsupported command are skipped', () {
|
|
final data = Uint8List.fromList([0xCC, 0xAB, 0x07, ...monitorFrame]);
|
|
expect(buf.add(data), [monitorFrame]);
|
|
});
|
|
|
|
test('exact keepalive is emitted, other A5 sequences are skipped', () {
|
|
expect(buf.add(apolloKeepalivePacket), [apolloKeepalivePacket]);
|
|
final data = Uint8List.fromList([0xA5, 0x02, 0x00, 0x00, ...monitorFrame]);
|
|
expect(buf.add(data), [monitorFrame]);
|
|
});
|
|
|
|
test('buffer size cap keeps the newest bytes', () {
|
|
final small = ApolloFrameBuffer(maxLength: 64);
|
|
small.add(Uint8List.fromList(List.filled(1000, 0x01)));
|
|
expect(small.length, lessThanOrEqualTo(64));
|
|
// Still recovers afterwards.
|
|
expect(small.add(monitorFrame), [monitorFrame]);
|
|
});
|
|
|
|
test('a garbage byte does not wedge parsing permanently', () {
|
|
buf.add(Uint8List.fromList([0xAA]));
|
|
buf.add(Uint8List.fromList([0x00]));
|
|
// 23 more junk bytes complete a fake 25-byte candidate with a bad CRC.
|
|
buf.add(Uint8List.fromList(List.filled(23, 0x55)));
|
|
expect(buf.add(monitorFrame), [monitorFrame]);
|
|
});
|
|
});
|
|
|
|
group('monitor parser', () {
|
|
test('synthetic vector, scaling flag true', () {
|
|
final m = parseApolloMonitorFrame(monitorFrame, internalSpeedScalingFlag: true);
|
|
expect(m.gear, 2);
|
|
expect(m.batteryLevel, 75);
|
|
expect(m.rawSpeed, 250);
|
|
expect(m.speed, 25.0);
|
|
expect(m.voltage, 48.0);
|
|
expect(m.current, 5.0);
|
|
expect(m.power, 240.0);
|
|
expect(m.motorTemperature, 35);
|
|
expect(m.controllerTemperature, 40);
|
|
expect(m.tripDistance, 12.3);
|
|
expect(m.odometer, 1234.5);
|
|
expect(m.atmosphereLight, isTrue);
|
|
expect(m.unlocked, isTrue);
|
|
expect(m.headlight, isTrue);
|
|
expect(m.rightTurnSignal, isFalse);
|
|
expect(m.leftTurnSignal, isFalse);
|
|
expect(m.cruiseControl, isTrue);
|
|
expect(m.imperial, isTrue);
|
|
expect(m.bootMode, isFalse);
|
|
});
|
|
|
|
test('scaling flag false gives raw/1000', () {
|
|
final m = parseApolloMonitorFrame(monitorFrame, internalSpeedScalingFlag: false);
|
|
expect(m.speed, 0.25);
|
|
});
|
|
|
|
test('speed uses the max of source A and B', () {
|
|
// A = 0x00FA (250), B = 0x00C8 (200) in the vector. Swap them.
|
|
final swapped = patched(monitorFrame, {6: 0x00, 7: 0xC8, 8: 0x00, 9: 0xFA});
|
|
expect(parseApolloMonitorFrame(swapped, internalSpeedScalingFlag: true).rawSpeed, 250);
|
|
final bBigger = patched(monitorFrame, {8: 0x01, 9: 0x00});
|
|
expect(parseApolloMonitorFrame(bBigger, internalSpeedScalingFlag: true).rawSpeed, 256);
|
|
});
|
|
|
|
test('negative current and derived power', () {
|
|
// -5.0 A = -320 = 0xFEC0
|
|
final f = patched(monitorFrame, {12: 0xFE, 13: 0xC0});
|
|
final m = parseApolloMonitorFrame(f, internalSpeedScalingFlag: true);
|
|
expect(m.current, -5.0);
|
|
expect(m.power, -240.0);
|
|
});
|
|
|
|
test('power is rounded to one decimal', () {
|
|
// voltage 48.1 (0x01E1), current 1/64 A = 0.015625 -> 0.7515625 -> 0.8
|
|
final f = patched(monitorFrame, {10: 0x01, 11: 0xE1, 12: 0x00, 13: 0x01});
|
|
expect(parseApolloMonitorFrame(f, internalSpeedScalingFlag: true).power, 0.8);
|
|
});
|
|
|
|
test('negative temperatures', () {
|
|
final f = patched(monitorFrame, {14: 0xF6, 15: 0xEC}); // -10, -20
|
|
final m = parseApolloMonitorFrame(f, internalSpeedScalingFlag: true);
|
|
expect(m.motorTemperature, -10);
|
|
expect(m.controllerTemperature, -20);
|
|
});
|
|
|
|
test('24-bit odometer uses all three bytes', () {
|
|
final f = patched(monitorFrame, {18: 0x12, 19: 0x34, 20: 0x56});
|
|
expect(parseApolloMonitorFrame(f, internalSpeedScalingFlag: true).odometer, 0x123456 / 10.0);
|
|
});
|
|
|
|
test('each switch flag is independent', () {
|
|
final base = patched(monitorFrame, {21: 0x00, 22: 0x00});
|
|
var m = parseApolloMonitorFrame(base, internalSpeedScalingFlag: true);
|
|
expect([m.atmosphereLight, m.unlocked, m.rightTurnSignal, m.leftTurnSignal, m.headlight,
|
|
m.cruiseControl, m.imperial, m.bootMode],
|
|
everyElement(isFalse));
|
|
|
|
m = parseApolloMonitorFrame(patched(base, {21: 1 << 1}), internalSpeedScalingFlag: true);
|
|
expect(m.atmosphereLight, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {21: 1 << 3}), internalSpeedScalingFlag: true);
|
|
expect(m.unlocked, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {21: 1 << 5}), internalSpeedScalingFlag: true);
|
|
expect(m.rightTurnSignal, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {21: 1 << 6}), internalSpeedScalingFlag: true);
|
|
expect(m.leftTurnSignal, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {21: 1 << 7}), internalSpeedScalingFlag: true);
|
|
expect(m.headlight, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {22: 1 << 2}), internalSpeedScalingFlag: true);
|
|
expect(m.cruiseControl, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {22: 1 << 5}), internalSpeedScalingFlag: true);
|
|
expect(m.imperial, isTrue);
|
|
m = parseApolloMonitorFrame(patched(base, {22: 1 << 6}), internalSpeedScalingFlag: true);
|
|
expect(m.bootMode, isTrue);
|
|
});
|
|
|
|
test('corrupt byte is rejected by CRC', () {
|
|
final bad = Uint8List.fromList(monitorFrame)..[4] = 0x03;
|
|
expect(() => parseApolloMonitorFrame(bad, internalSpeedScalingFlag: true),
|
|
throwsFormatException);
|
|
});
|
|
|
|
test('rejects wrong command or length', () {
|
|
expect(() => parseApolloMonitorFrame(baseFrame, internalSpeedScalingFlag: true),
|
|
throwsFormatException);
|
|
expect(() => parseApolloMonitorFrame(monitorFrame.sublist(1), internalSpeedScalingFlag: true),
|
|
throwsFormatException);
|
|
});
|
|
});
|
|
|
|
group('base parser', () {
|
|
test('synthetic vector', () {
|
|
final b = parseApolloBaseFrame(baseFrame);
|
|
expect(b.limitCruise, 25);
|
|
expect(b.limitMode1, 6);
|
|
expect(b.limitMode2, 12);
|
|
expect(b.limitMode3, 20);
|
|
expect(b.batteryTemperature, 30);
|
|
expect(b.totalBatteryCapacity, 10000);
|
|
expect(b.remainingBatteryCapacity, 5000);
|
|
expect(b.batteryCycles, 100);
|
|
expect(b.displayId, '12ab');
|
|
expect(b.displayVersion, 'V2.5.17');
|
|
expect(b.ctrlSn, isTrue);
|
|
expect(b.ctrlMp3, isTrue);
|
|
expect(b.ctrlRgb, isTrue);
|
|
expect(b.ctrlBms, isTrue);
|
|
expect(b.internalSpeedScalingFlag, isTrue);
|
|
expect(b.faultEnable, isTrue); // frame[8] = 0x80
|
|
expect(b.e9, isFalse);
|
|
});
|
|
|
|
test('negative battery temperature', () {
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {7: 0xF1})).batteryTemperature, -15);
|
|
});
|
|
|
|
test('capacity fields are big-endian', () {
|
|
final b = parseApolloBaseFrame(patched(baseFrame, {12: 0x01, 13: 0x02, 14: 0x03, 15: 0x04, 16: 0x05, 17: 0x06}));
|
|
expect(b.totalBatteryCapacity, 0x0102);
|
|
expect(b.remainingBatteryCapacity, 0x0304);
|
|
expect(b.batteryCycles, 0x0506);
|
|
});
|
|
|
|
test('display id 0000 is absent, otherwise lowercase hex padded', () {
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {18: 0, 19: 0})).displayId, isNull);
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {18: 0x0A, 19: 0x0B})).displayId, '0a0b');
|
|
});
|
|
|
|
test('display version formats V%d.%d.%d', () {
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {20: 0, 21: 10, 22: 255})).displayVersion, 'V0.10.255');
|
|
});
|
|
|
|
test('capability bits are independent', () {
|
|
final none = parseApolloBaseFrame(patched(baseFrame, {10: 0x00}));
|
|
expect([none.ctrlSn, none.ctrlMp3, none.ctrlRgb, none.ctrlBms, none.internalSpeedScalingFlag],
|
|
everyElement(isFalse));
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {10: 1 << 0})).ctrlSn, isTrue);
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {10: 1 << 1})).ctrlMp3, isTrue);
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {10: 1 << 2})).ctrlRgb, isTrue);
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {10: 1 << 3})).ctrlBms, isTrue);
|
|
expect(parseApolloBaseFrame(patched(baseFrame, {10: 1 << 4})).internalSpeedScalingFlag, isTrue);
|
|
});
|
|
|
|
test('fault flags, including the duplicated frame[8] bit 3 mapping', () {
|
|
final a = parseApolloBaseFrame(patched(baseFrame, {8: (1 << 1) | (1 << 2), 9: 0}));
|
|
expect(a.e9, isTrue);
|
|
expect(a.f1, isTrue);
|
|
expect(a.f2, isFalse);
|
|
expect(a.ctrlFaultEarlyWarning, isFalse);
|
|
expect(a.faultEnable, isFalse);
|
|
|
|
// Apollo 4.8.18340 maps both f2 and ctrlFaultEarlyWarning to bit 3.
|
|
final b = parseApolloBaseFrame(patched(baseFrame, {8: 1 << 3}));
|
|
expect(b.f2, isTrue);
|
|
expect(b.ctrlFaultEarlyWarning, isTrue);
|
|
|
|
final c = parseApolloBaseFrame(patched(baseFrame, {9: (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 7)}));
|
|
expect([c.e1, c.e2, c.e3, c.e4, c.e7], everyElement(isTrue));
|
|
final d = parseApolloBaseFrame(patched(baseFrame, {9: 0}));
|
|
expect([d.e1, d.e2, d.e3, d.e4, d.e7], everyElement(isFalse));
|
|
});
|
|
|
|
test('corrupt byte is rejected by CRC', () {
|
|
final bad = Uint8List.fromList(baseFrame)..[3] = 0x20;
|
|
expect(() => parseApolloBaseFrame(bad), throwsFormatException);
|
|
});
|
|
});
|
|
|
|
group('set-base packet builder', () {
|
|
Uint8List build({
|
|
int gear = 2,
|
|
bool headlight = true,
|
|
bool atmosphereLight = false,
|
|
bool cruiseControl = false,
|
|
bool bootMode = false,
|
|
bool imperial = true,
|
|
bool unlocked = false,
|
|
}) =>
|
|
buildApolloSetBasePacket(
|
|
gearPosition: gear,
|
|
headlight: headlight,
|
|
atmosphereLight: atmosphereLight,
|
|
cruiseControl: cruiseControl,
|
|
bootMode: bootMode,
|
|
imperial: imperial,
|
|
unlocked: unlocked,
|
|
limitCruise: 25,
|
|
limitMode1: 6,
|
|
limitMode2: 12,
|
|
limitMode3: 20,
|
|
);
|
|
|
|
test('exact packet for brief vector 1 (all zero)', () {
|
|
final p = buildApolloSetBasePacket(
|
|
gearPosition: 0,
|
|
headlight: false,
|
|
atmosphereLight: false,
|
|
cruiseControl: false,
|
|
bootMode: false,
|
|
imperial: false,
|
|
unlocked: false,
|
|
limitCruise: 0,
|
|
limitMode1: 0,
|
|
limitMode2: 0,
|
|
limitMode3: 0,
|
|
);
|
|
expect(p, hex('AB 00 0A 00 00 00 00 00 0B 6A'));
|
|
});
|
|
|
|
test('exact packet for brief vector 2 (unlocked with limits)', () {
|
|
final p = buildApolloSetBasePacket(
|
|
gearPosition: 0,
|
|
headlight: false,
|
|
atmosphereLight: false,
|
|
cruiseControl: false,
|
|
bootMode: false,
|
|
imperial: false,
|
|
unlocked: true,
|
|
limitCruise: 25,
|
|
limitMode1: 6,
|
|
limitMode2: 12,
|
|
limitMode3: 20,
|
|
);
|
|
expect(p, hex('AB 00 0A 80 19 06 0C 14 E8 E6'));
|
|
expect(apolloValidateFrame(p), isTrue);
|
|
});
|
|
|
|
test('is exactly 10 bytes with header AB 00 0A and the four limits', () {
|
|
final p = build();
|
|
expect(p.length, 10);
|
|
expect(p.sublist(0, 3), hex('AB 00 0A'));
|
|
expect(p.sublist(4, 8), [25, 6, 12, 20]);
|
|
});
|
|
|
|
/// Asserts that toggling one control changes exactly one FLAGS bit and
|
|
/// nothing else before the CRC.
|
|
void expectOnlyBitChanges(Uint8List a, Uint8List b, int bit) {
|
|
expect(a.sublist(0, 3), b.sublist(0, 3));
|
|
expect(a.sublist(4, 8), b.sublist(4, 8), reason: 'speed limits must be preserved');
|
|
expect(a[3] ^ b[3], 1 << bit, reason: 'only FLAGS bit $bit may change');
|
|
expect(apolloValidateFrame(a), isTrue);
|
|
expect(apolloValidateFrame(b), isTrue);
|
|
}
|
|
|
|
test('unlock changes only FLAGS bit 7', () {
|
|
expectOnlyBitChanges(build(unlocked: false), build(unlocked: true), 7);
|
|
});
|
|
test('headlight changes only FLAGS bit 2', () {
|
|
expectOnlyBitChanges(build(headlight: false), build(headlight: true), 2);
|
|
});
|
|
test('atmosphere light changes only FLAGS bit 3', () {
|
|
expectOnlyBitChanges(build(atmosphereLight: false), build(atmosphereLight: true), 3);
|
|
});
|
|
test('cruise changes only FLAGS bit 4', () {
|
|
expectOnlyBitChanges(build(cruiseControl: false), build(cruiseControl: true), 4);
|
|
});
|
|
test('boot mode bit 5 and imperial bit 6', () {
|
|
expectOnlyBitChanges(build(bootMode: false), build(bootMode: true), 5);
|
|
expectOnlyBitChanges(build(imperial: false), build(imperial: true), 6);
|
|
});
|
|
test('gear occupies bits 0-1 only', () {
|
|
expect(build(gear: 0)[3] & 0x03, 0);
|
|
expect(build(gear: 3)[3] & 0x03, 3);
|
|
expect(build(gear: 7)[3] & 0x03, 3);
|
|
});
|
|
test('rejects limits outside one byte', () {
|
|
expect(
|
|
() => buildApolloSetBasePacket(
|
|
gearPosition: 0, headlight: false, atmosphereLight: false, cruiseControl: false,
|
|
bootMode: false, imperial: false, unlocked: false,
|
|
limitCruise: 256, limitMode1: 0, limitMode2: 0, limitMode3: 0,
|
|
),
|
|
throwsArgumentError,
|
|
);
|
|
});
|
|
});
|
|
}
|