test querying CAN interface attributes

ardera · Jun 19, 2023 · 99473e7 · 99473e7
1 parent 51d1923
commit 99473e7
Show file tree

Hide file tree

Showing 3 changed files with 113 additions and 38 deletions.
diff --git a/packages/linux_can_test_app/integration_test/can_test.dart b/packages/linux_can_test_app/integration_test/can_test.dart
@@ -4,21 +4,21 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:linux_can/linux_can.dart';
 
 void main() {
-  testWidgets('querying CAN devices', (_) async {
+  testWidgets('LinuxCan.instance.devices returns normally', (_) async {
     expect(
       () => LinuxCan.instance.devices,
       returnsNormally,
     );
   }, tags: 'pi3-can');
 
-  group('general CAN', () {
+  group('', () {
     late List<CanDevice> devices;
 
     setUp(() {
       devices = LinuxCan.instance.devices;
     });
 
-    testWidgets('CAN device list details', (_) async {
+    testWidgets('LinuxCan.instance.devices works', (_) async {
       expect(devices, hasLength(2));
 
       expect(devices[0].networkInterface.index, equals(3));
@@ -27,7 +27,7 @@ void main() {
       expect(devices[1].networkInterface.name, equals('can1'));
     }, tags: 'pi3-can');
 
-    group('control can0 and can1', () {
+    group('CanDevice', () {
       late CanDevice can0;
       late CanDevice can1;
 
@@ -36,6 +36,94 @@ void main() {
         can1 = devices.singleWhere((device) => device.networkInterface.name == 'can1');
       });
 
+      testWidgets('can0 queryAttributes', (_) async {
+        final attributes = can0.queryAttributes();
+
+        expect(
+          attributes.interfaceFlags,
+          equals({
+            NetInterfaceFlag.up,
+            NetInterfaceFlag.running,
+            NetInterfaceFlag.noArp,
+            NetInterfaceFlag.lowerUp,
+            NetInterfaceFlag.echo
+          }),
+        );
+        expect(attributes.txQueueLength, greaterThanOrEqualTo(1000));
+        expect(attributes.operState, equals(NetInterfaceOperState.up));
+
+        /// TODO: Implement stats
+        expect(attributes.stats, anything);
+        expect(attributes.numTxQueues, equals(1));
+        expect(attributes.numRxQueues, equals(1));
+
+        expect(attributes.bitTiming?.bitrate, equals(125000));
+        expect(attributes.bitTimingLimits?.hardwareName, equals('mcp251x'));
+        expect(attributes.bitTimingLimits?.timeSegment1Min, equals(3));
+        expect(attributes.bitTimingLimits?.timeSegment1Max, equals(16));
+        expect(attributes.bitTimingLimits?.timeSegment2Min, equals(2));
+        expect(attributes.bitTimingLimits?.timeSegment2Max, equals(8));
+        expect(attributes.bitTimingLimits?.bitRatePrescalerMin, equals(1));
+        expect(attributes.bitTimingLimits?.bitRatePrescalerMax, equals(64));
+        expect(attributes.bitTimingLimits?.bitRatePrescalerIncrement, equals(1));
+
+        expect(attributes.clockFrequency, equals(8000000));
+        expect(attributes.state, equals(CanState.active));
+        expect(attributes.restartDelay, equals(Duration.zero));
+        expect(attributes.busErrorCounters, isNull);
+        expect(attributes.dataBitTiming, isNull);
+        expect(attributes.dataBitTimingLimits, isNull);
+        expect(attributes.termination, isNull);
+        expect(attributes.fixedTermination, isNull);
+        expect(attributes.fixedBitrate, isNull);
+        expect(attributes.fixedDataBitrate, isNull);
+        expect(attributes.maxBitrate, equals(0));
+      }, tags: 'pi3-can');
+
+      testWidgets('can1 attributes', (_) async {
+        final attributes = can1.queryAttributes();
+
+        expect(
+          attributes.interfaceFlags,
+          equals({
+            NetInterfaceFlag.up,
+            NetInterfaceFlag.running,
+            NetInterfaceFlag.noArp,
+            NetInterfaceFlag.lowerUp,
+            NetInterfaceFlag.echo
+          }),
+        );
+        expect(attributes.txQueueLength, greaterThanOrEqualTo(1000));
+        expect(attributes.operState, equals(NetInterfaceOperState.up));
+
+        /// TODO: Implement stats
+        expect(attributes.stats, anything);
+        expect(attributes.numTxQueues, equals(1));
+        expect(attributes.numRxQueues, equals(1));
+
+        expect(attributes.bitTiming?.bitrate, equals(125000));
+        expect(attributes.bitTimingLimits?.hardwareName, equals('mcp251x'));
+        expect(attributes.bitTimingLimits?.timeSegment1Min, equals(3));
+        expect(attributes.bitTimingLimits?.timeSegment1Max, equals(16));
+        expect(attributes.bitTimingLimits?.timeSegment2Min, equals(2));
+        expect(attributes.bitTimingLimits?.timeSegment2Max, equals(8));
+        expect(attributes.bitTimingLimits?.bitRatePrescalerMin, equals(1));
+        expect(attributes.bitTimingLimits?.bitRatePrescalerMax, equals(64));
+        expect(attributes.bitTimingLimits?.bitRatePrescalerIncrement, equals(1));
+
+        expect(attributes.clockFrequency, equals(8000000));
+        expect(attributes.state, equals(CanState.active));
+        expect(attributes.restartDelay, equals(Duration.zero));
+        expect(attributes.busErrorCounters, isNull);
+        expect(attributes.dataBitTiming, isNull);
+        expect(attributes.dataBitTimingLimits, isNull);
+        expect(attributes.termination, isNull);
+        expect(attributes.fixedTermination, isNull);
+        expect(attributes.fixedBitrate, isNull);
+        expect(attributes.fixedDataBitrate, isNull);
+        expect(attributes.maxBitrate, equals(0));
+      }, tags: 'pi3-can');
+
       testWidgets('opening & closing can0 device', (_) async {
         late CanSocket socket;
         expect(
@@ -61,7 +149,7 @@ void main() {
       }, tags: 'pi3-can');
     });
 
-    group('use can0 and can1', () {
+    group('CanSocket', () {
       late CanSocket can0;
       late CanSocket can1;
 
@@ -79,6 +167,10 @@ void main() {
         can1.close();
       });
 
+      testWidgets('can0 send buf size', (_) async {
+        expect(can0.sendBufSize, equals(22 * 4096));
+      }, tags: 'pi3-can');
+
       testWidgets('writing standard CAN frame to can0', (_) async {
         expect(
           () => can0.write(CanFrame.standard(id: 0x123, data: [0x01, 0x02, 0x03, 0x04])),

diff --git a/packages/linux_can_test_app/lib/main.dart b/packages/linux_can_test_app/lib/main.dart
@@ -1,41 +1,24 @@
 import 'package:flutter/material.dart';
+import 'package:linux_can/linux_can.dart';
 
-void main() {
-  runApp(const MyApp());
-}
+void main() async {
+  final can0 = LinuxCan.instance.devices.singleWhere((device) => device.networkInterface.name == 'can0');
+  final can1 = LinuxCan.instance.devices.singleWhere((device) => device.networkInterface.name == 'can1');
 
-class MyApp extends StatelessWidget {
-  const MyApp({super.key});
-
-  @override
-  Widget build(BuildContext context) {
-    return MaterialApp(
-      title: 'linux_can Test App',
-      theme: ThemeData(
-        primarySwatch: Colors.blue,
-      ),
-      home: const MyHomePage(title: 'linux_can Test App'),
-    );
-  }
-}
+  await Future.delayed(const Duration(seconds: 3));
 
-class MyHomePage extends StatefulWidget {
-  const MyHomePage({super.key, required this.title});
+  can0.queryAttributes();
 
-  final String title;
+  final can1Attributes = can1.queryAttributes();
+  debugPrint('can1 attributes: $can1Attributes');
 
-  @override
-  State<MyHomePage> createState() => _MyHomePageState();
-}
+  debugPrint('can1 hardwareName: ${can1.hardwareName}');
+
+  debugPrint('can1 xstats: ${can1.xstats}');
+
+  debugPrint('can1 txqlen: ${can1.txQueueLength}');
 
-class _MyHomePageState extends State<MyHomePage> {
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      appBar: AppBar(
-        title: Text(widget.title),
-      ),
-      body: Container(),
-    );
+  for (var i = 0; i < 50; i++) {
+    can1.hardwareName;
   }
 }
diff --git a/packages/linux_can_test_app/pubspec.yaml b/packages/linux_can_test_app/pubspec.yaml
@@ -5,7 +5,7 @@ publish_to: 'none'
 version: 1.0.0+1
 
 environment:
-  sdk: '>=2.19.6 <3.0.0'
+  sdk: '>=3.0.0 <4.0.0'
 
 dependencies:
   flutter: