Add initial load scheduling and tests for USB screen and frame codec functionality

test/screens/usb_flow_test.dart

@@ -0,0 +1,125 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+
+import 'package:meshcore_open/connector/meshcore_connector.dart';
+import 'package:meshcore_open/l10n/app_localizations.dart';
+import 'package:meshcore_open/screens/connection_choice_screen.dart';
+import 'package:meshcore_open/screens/usb_screen.dart';
+import 'package:meshcore_open/utils/platform_info.dart';
+
+class _FakeMeshCoreConnector extends MeshCoreConnector {
+  _FakeMeshCoreConnector({
+    this.initialState = MeshCoreConnectionState.disconnected,
+    List<String>? ports,
+  }) : _ports = ports ?? <String>[];
+
+  final MeshCoreConnectionState initialState;
+  final List<String> _ports;
+
+  String? requestPortLabel;
+  int connectUsbCalls = 0;
+  String? lastConnectPortName;
+  String? fakeActiveUsbPort;
+  bool fakeUsbTransportConnected = false;
+
+  @override
+  MeshCoreConnectionState get state => initialState;
+
+  @override
+  String? get activeUsbPort => fakeActiveUsbPort;
+
+  @override
+  bool get isUsbTransportConnected => fakeUsbTransportConnected;
+
+  @override
+  Future<List<String>> listUsbPorts() async => List<String>.from(_ports);
+
+  @override
+  Future<void> connectUsb({
+    required String portName,
+    int baudRate = 115200,
+  }) async {
+    connectUsbCalls += 1;
+    lastConnectPortName = portName;
+  }
+
+  @override
+  void setUsbRequestPortLabel(String label) {
+    requestPortLabel = label;
+  }
+}
+
+Widget _buildTestApp({
+  required MeshCoreConnector connector,
+  required Widget child,
+}) {
+  return ChangeNotifierProvider<MeshCoreConnector>.value(
+    value: connector,
+    child: MaterialApp(
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      home: child,
+    ),
+  );
+}
+
+void main() {
+  testWidgets('UsbScreen passes localized chooser label to connector', (
+    tester,
+  ) async {
+    final connector = _FakeMeshCoreConnector();
+
+    await tester.pumpWidget(
+      _buildTestApp(connector: connector, child: const UsbScreen()),
+    );
+    await tester.pumpAndSettle();
+
+    expect(connector.requestPortLabel, 'Select a USB device');
+  });
+
+  testWidgets(
+    'UsbScreen does not call connectUsb when connector is not disconnected',
+    (tester) async {
+      final connector = _FakeMeshCoreConnector(
+        initialState: MeshCoreConnectionState.connected,
+        ports: <String>['COM6 - USB Serial Device (COM6)'],
+      );
+
+      await tester.pumpWidget(
+        _buildTestApp(connector: connector, child: const UsbScreen()),
+      );
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.widgetWithText(FilledButton, 'Connect'));
+      await tester.pump();
+
+      expect(connector.connectUsbCalls, 0);
+      expect(find.byType(CircularProgressIndicator), findsNothing);
+    },
+  );
+
+  testWidgets('ConnectionChoiceScreen USB button reflects platform support', (
+    tester,
+  ) async {
+    final connector = _FakeMeshCoreConnector();
+
+    await tester.pumpWidget(
+      _buildTestApp(
+        connector: connector,
+        child: const ConnectionChoiceScreen(),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    final usbButton = tester.widget<ElevatedButton>(
+      find.widgetWithText(ElevatedButton, 'USB'),
+    );
+
+    if (PlatformInfo.supportsUsbSerial) {
+      expect(usbButton.onPressed, isNotNull);
+    } else {
+      expect(usbButton.onPressed, isNull);
+    }
+  });
+}

test/services/usb_serial_frame_codec_test.dart

@@ -13,6 +13,21 @@ void main() {
     );
   });
 
+  test('wrapUsbSerialTxFrame rejects payloads above protocol maximum', () {
+    final payload = Uint8List(usbSerialMaxPayloadLength + 1);
+
+    expect(
+      () => wrapUsbSerialTxFrame(payload),
+      throwsA(
+        isA<ArgumentError>().having(
+          (error) => error.name,
+          'name',
+          'payload.length',
+        ),
+      ),
+    );
+  });
+
   test('UsbSerialFrameDecoder buffers partial frames until complete', () {
     final decoder = UsbSerialFrameDecoder();
 
@@ -81,4 +96,28 @@ void main() {
       expect(packets[1].payload, orderedEquals(<int>[0x33]));
     },
   );
+
+  test(
+    'UsbSerialFrameDecoder drops oversized frames and resyncs on the next valid packet',
+    () {
+      final decoder = UsbSerialFrameDecoder();
+
+      final packets = decoder.ingest(
+        Uint8List.fromList(<int>[
+          usbSerialRxFrameStart,
+          0xAD,
+          0x00,
+          0x99,
+          usbSerialRxFrameStart,
+          0x01,
+          0x00,
+          0x44,
+        ]),
+      );
+
+      expect(packets, hasLength(1));
+      expect(packets.single.isRxFrame, isTrue);
+      expect(packets.single.payload, orderedEquals(<int>[0x44]));
+    },
+  );
 }

test/utils/usb_port_labels_test.dart

@@ -50,7 +50,18 @@ void main() {
   test('describeWebUsbPort returns chooser label when no usb ids exist', () {
     expect(
       describeWebUsbPort(vendorId: null, productId: null),
-      usbRequestPortLabel,
+      'Choose USB Device',
+    );
+  });
+
+  test('describeWebUsbPort uses caller-provided chooser label', () {
+    expect(
+      describeWebUsbPort(
+        vendorId: null,
+        productId: null,
+        requestPortLabel: 'Select a USB device',
+      ),
+      'Select a USB device',
     );
   });