dlt_parse/storage/
dlt_storage_reader.rs

1use std::io::{BufRead, ErrorKind, Read};
2#[cfg(not(test))]
3use std::vec::Vec;
4
5use crate::error::{DltMessageLengthTooSmallError, ReadError, UnsupportedDltVersionError};
6use crate::storage::StorageHeader;
7use crate::*;
8
9use super::StorageSlice;
10
11/// Reader to parse a dlt storage file.
12///
13/// # Example
14/// ```no_run
15/// # let dlt_file = "dummy.dlt";
16/// use std::{fs::File, io::BufReader};
17/// use dlt_parse::storage::DltStorageReader;
18///
19/// let dlt_file = File::open(dlt_file).expect("failed to open file");
20/// let mut reader = DltStorageReader::new(BufReader::new(dlt_file));
21///
22/// while let Some(msg_result) = reader.next_packet() {
23///     let msg = msg_result.expect("failed to parse dlt packet");
24///
25///     // the storage header contains the ecu id and the timestamp
26///     println!("{:?}", msg.storage_header);
27///
28///     // the dlt packet
29///     println!("{:?}", msg.packet);
30/// }
31/// ```
32#[cfg(feature = "std")]
33#[derive(Debug)]
34pub struct DltStorageReader<R: Read + BufRead> {
35    reader: R,
36    /// Continue search for next storage header if it is missing.
37    is_seeking_storage_pattern: bool,
38    last_packet: Vec<u8>,
39    read_error: bool,
40    num_read_packets: usize,
41    num_pattern_seeks: usize,
42}
43
44#[cfg(feature = "std")]
45impl<R: Read + BufRead> DltStorageReader<R> {
46    /// Creates a new reader.
47    pub fn new(reader: R) -> DltStorageReader<R> {
48        DltStorageReader {
49            reader,
50            is_seeking_storage_pattern: true,
51            last_packet: Vec::with_capacity(u16::MAX as usize),
52            read_error: false,
53            num_read_packets: 0,
54            num_pattern_seeks: 0,
55        }
56    }
57
58    /// Creates a new reader that does not allow corrupted data
59    /// and does NOT seek to the next storage pattern whenever
60    /// corrupted data is encountered.
61    pub fn new_strict(reader: R) -> DltStorageReader<R> {
62        DltStorageReader {
63            reader,
64            is_seeking_storage_pattern: false,
65            last_packet: Vec::with_capacity(u16::MAX as usize),
66            read_error: false,
67            num_read_packets: 0,
68            num_pattern_seeks: 0,
69        }
70    }
71
72    /// Returns if the reader will seek storage headers if corrupted
73    /// data is present between packets.
74    #[inline]
75    pub fn is_seeking_storage_pattern(&self) -> bool {
76        self.is_seeking_storage_pattern
77    }
78
79    /// Returns the number of DLT packets read.
80    #[inline]
81    pub fn num_read_packets(&self) -> usize {
82        self.num_read_packets
83    }
84
85    /// Returns the number of times corrupt data was encountered and the
86    /// next "storage pattern" ([`crate::storage::StorageHeader::PATTERN_AT_START`])
87    /// had to be searched in the data stream.
88    #[inline]
89    pub fn num_pattern_seeks(&self) -> usize {
90        self.num_pattern_seeks
91    }
92
93    /// Returns the next DLT packet.
94    pub fn next_packet(&mut self) -> Option<Result<StorageSlice<'_>, ReadError>> {
95        // check if iteration is done based as
96        if self.read_error {
97            return None;
98        }
99
100        // goto & read storage header
101        if false == self.is_seeking_storage_pattern {
102            // check if there is data left in the reader
103            match self.reader.fill_buf() {
104                Ok(slice) => {
105                    if slice.is_empty() {
106                        return None;
107                    }
108                }
109                Err(err) => {
110                    self.read_error = true;
111                    return Some(Err(err.into()));
112                }
113            }
114
115            // in the non seeking version a storage header is expected to be directly present
116            let mut storage_header_data = [0u8; StorageHeader::BYTE_LEN];
117            if let Err(err) = self.reader.read_exact(&mut storage_header_data) {
118                self.read_error = true;
119                return Some(Err(err.into()));
120            }
121            let storage_header = match StorageHeader::from_bytes(storage_header_data) {
122                Ok(value) => value,
123                Err(err) => {
124                    self.read_error = true;
125                    return Some(Err(err.into()));
126                }
127            };
128
129            // read the start
130            let mut header_start = [0u8; 4];
131            if let Err(err) = self.reader.read_exact(&mut header_start) {
132                self.read_error = true;
133                return Some(Err(err.into()));
134            }
135
136            // check version
137            let version = (header_start[0] >> 5) & MAX_VERSION;
138            if 0 != version && 1 != version {
139                self.read_error = true;
140                return Some(Err(ReadError::UnsupportedDltVersion(
141                    UnsupportedDltVersionError {
142                        unsupported_version: version,
143                    },
144                )));
145            }
146
147            // check length to be at least 4
148            let length = u16::from_be_bytes([header_start[2], header_start[3]]) as usize;
149            if length < 4 {
150                self.read_error = true;
151                return Some(Err(ReadError::DltMessageLengthTooSmall(
152                    DltMessageLengthTooSmallError {
153                        required_length: 4,
154                        actual_length: length,
155                    },
156                )));
157            }
158
159            // read the complete packet
160            self.last_packet.clear();
161            self.last_packet.reserve(length);
162            self.last_packet.extend_from_slice(&header_start);
163            if length > 4 {
164                self.last_packet.resize(length, 0);
165                if let Err(err) = self.reader.read_exact(&mut self.last_packet[4..]) {
166                    self.read_error = true;
167                    return Some(Err(err.into()));
168                }
169            }
170
171            let packet = match DltPacketSlice::from_slice(&self.last_packet) {
172                Ok(packet) => packet,
173                Err(err) => {
174                    self.read_error = true;
175                    return Some(Err(err.into()));
176                }
177            };
178
179            // packet successfully read
180            self.num_read_packets += 1;
181
182            Some(Ok(StorageSlice {
183                storage_header,
184                packet,
185            }))
186        } else {
187            loop {
188                // seek the next storage header pattern
189                let mut pattern_elements_found = 0;
190                let mut storage_pattern_error = false;
191                while pattern_elements_found < StorageHeader::PATTERN_AT_START.len() {
192                    // load data
193                    let slice = match self.reader.fill_buf() {
194                        Ok(slice) => {
195                            if slice.is_empty() {
196                                self.read_error = true;
197                                return None;
198                            }
199                            slice
200                        }
201                        Err(err) => {
202                            self.read_error = true;
203                            return Some(Err(err.into()));
204                        }
205                    };
206
207                    // check for the pattern
208                    let mut consumed_len = 0;
209                    for d in slice {
210                        if *d == StorageHeader::PATTERN_AT_START[pattern_elements_found] {
211                            pattern_elements_found += 1;
212                        } else {
213                            storage_pattern_error = true;
214                            pattern_elements_found = 0;
215                        }
216                        consumed_len += 1;
217                        if pattern_elements_found >= StorageHeader::PATTERN_AT_START.len() {
218                            break;
219                        }
220                    }
221                    self.reader.consume(consumed_len);
222                }
223                if storage_pattern_error {
224                    self.num_pattern_seeks += 1;
225                }
226
227                // read the rest of the storage header
228                let mut bytes =
229                    [0u8; StorageHeader::BYTE_LEN - StorageHeader::PATTERN_AT_START.len()];
230                if let Err(err) = self.reader.read_exact(&mut bytes) {
231                    self.read_error = true;
232                    if err.kind() == ErrorKind::UnexpectedEof {
233                        return None;
234                    } else {
235                        return Some(Err(err.into()));
236                    }
237                }
238
239                let storage_header = StorageHeader {
240                    timestamp_seconds: u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
241                    timestamp_microseconds: u32::from_le_bytes([
242                        bytes[4], bytes[5], bytes[6], bytes[7],
243                    ]),
244                    ecu_id: [bytes[8], bytes[9], bytes[10], bytes[11]],
245                };
246
247                // read the start
248                let mut header_start = [0u8; 4];
249                if let Err(err) = self.reader.read_exact(&mut header_start) {
250                    self.read_error = true;
251                    if err.kind() == ErrorKind::UnexpectedEof {
252                        return None;
253                    } else {
254                        return Some(Err(err.into()));
255                    }
256                }
257
258                // check version
259                let version = (header_start[0] >> 5) & MAX_VERSION;
260                if 0 != version && 1 != version {
261                    continue;
262                }
263
264                // calculate the minimum size based on the header flags
265                let header_len = if 0 != header_start[0] & ECU_ID_FLAG {
266                    4 + 4
267                } else {
268                    4
269                };
270
271                let header_len = if 0 != header_start[0] & SESSION_ID_FLAG {
272                    header_len + 4
273                } else {
274                    header_len
275                };
276
277                let header_len = if 0 != header_start[0] & TIMESTAMP_FLAG {
278                    header_len + 4
279                } else {
280                    header_len
281                };
282
283                let header_len = if 0 != header_start[0] & EXTDENDED_HEADER_FLAG {
284                    header_len + 10
285                } else {
286                    header_len
287                };
288
289                // check length to be at least 4
290                let length = u16::from_be_bytes([header_start[2], header_start[3]]) as usize;
291                if length < header_len {
292                    continue;
293                }
294
295                // read the complete packet
296                self.last_packet.clear();
297                self.last_packet.reserve(length);
298                self.last_packet.extend_from_slice(&header_start);
299                if length > 4 {
300                    self.last_packet.resize(length, 0);
301                    if let Err(err) = self.reader.read_exact(&mut self.last_packet[4..]) {
302                        self.read_error = true;
303                        if err.kind() == ErrorKind::UnexpectedEof {
304                            return None;
305                        } else {
306                            return Some(Err(err.into()));
307                        }
308                    }
309                }
310
311                let packet = match DltPacketSlice::from_slice(&self.last_packet) {
312                    Ok(packet) => packet,
313                    Err(err) => {
314                        self.read_error = true;
315                        return Some(Err(err.into()));
316                    }
317                };
318
319                // packet successfully read
320                self.num_read_packets += 1;
321
322                return Some(Ok(StorageSlice {
323                    storage_header,
324                    packet,
325                }));
326            }
327        }
328    }
329}
330
331#[cfg(test)]
332#[cfg(feature = "std")]
333mod dlt_storage_reader_tests {
334    use super::*;
335    use std::format;
336    use std::io::{BufReader, Cursor};
337
338    /// Reader that returns an error when buffer_fill is called.
339    struct BufferFillErrorReader {}
340
341    impl Read for BufferFillErrorReader {
342        fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
343            Ok(0)
344        }
345    }
346
347    impl BufRead for BufferFillErrorReader {
348        fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
349            Err(std::io::Error::new(std::io::ErrorKind::Other, ""))
350        }
351
352        fn consume(&mut self, _amt: usize) {}
353    }
354
355    #[test]
356    fn debug() {
357        let r = DltStorageReader::new(BufReader::new(Cursor::new(&[])));
358        assert!(format!("{:?}", r).len() > 0);
359    }
360
361    #[test]
362    fn next_packet() {
363        use std::vec::Vec;
364
365        // empty reader
366        {
367            let mut r = DltStorageReader::new(BufReader::new(Cursor::new(&[])));
368            assert!(r.next_packet().is_none());
369            assert!(r.is_seeking_storage_pattern());
370            assert_eq!(0, r.num_read_packets());
371            assert_eq!(0, r.num_pattern_seeks());
372        }
373
374        // reader with working packets
375        {
376            // build two packets
377            let storage_header0 = StorageHeader {
378                timestamp_seconds: 1,
379                timestamp_microseconds: 2,
380                ecu_id: [0, 0, 0, 0],
381            };
382            let packet0 = {
383                let mut packet = Vec::new();
384                let mut header = DltHeader {
385                    is_big_endian: true,
386                    message_counter: 1,
387                    length: 0, // set afterwords
388                    ecu_id: None,
389                    session_id: None,
390                    timestamp: None,
391                    extended_header: None,
392                };
393                header.length = header.header_len() + 4;
394                header.write(&mut packet).unwrap();
395                // set version to 0
396                packet[0] = packet[0] & 0b0001_1111;
397                packet.extend_from_slice(&[1, 2, 3, 4]);
398                packet
399            };
400
401            let storage_header1 = StorageHeader {
402                timestamp_seconds: 3,
403                timestamp_microseconds: 4,
404                ecu_id: [5, 6, 7, 8],
405            };
406            let packet1 = {
407                let mut packet = Vec::new();
408                let mut header = DltHeader {
409                    is_big_endian: true,
410                    message_counter: 2,
411                    length: 0, // set afterwords
412                    ecu_id: None,
413                    session_id: None,
414                    timestamp: None,
415                    extended_header: None,
416                };
417                header.length = header.header_len() + 6;
418                header.write(&mut packet).unwrap();
419                packet.extend_from_slice(&[10, 11, 12, 13, 14, 15]);
420                packet
421            };
422
423            // compose data
424            let mut v = Vec::new();
425            v.extend_from_slice(&storage_header0.to_bytes());
426            v.extend_from_slice(&packet0);
427            v.extend_from_slice(&storage_header1.to_bytes());
428            v.extend_from_slice(&packet1);
429            // add some dummy data to test the seeking of the storage pattern
430            v.extend_from_slice(&[0, 0, 0]);
431            v.extend_from_slice(&storage_header1.to_bytes());
432            v.extend_from_slice(&packet1);
433            v.extend_from_slice(&[0, 0, 0, 0, 0, 0]);
434
435            // check result
436            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&v[..])));
437            assert!(reader.is_seeking_storage_pattern());
438            assert_eq!(0, reader.num_read_packets());
439            assert_eq!(0, reader.num_pattern_seeks());
440
441            assert_eq!(
442                reader.next_packet().unwrap().unwrap(),
443                StorageSlice {
444                    storage_header: storage_header0,
445                    packet: DltPacketSlice::from_slice(&packet0).unwrap()
446                }
447            );
448            assert_eq!(1, reader.num_read_packets());
449            assert_eq!(0, reader.num_pattern_seeks());
450
451            assert_eq!(
452                reader.next_packet().unwrap().unwrap(),
453                StorageSlice {
454                    storage_header: storage_header1.clone(),
455                    packet: DltPacketSlice::from_slice(&packet1).unwrap()
456                }
457            );
458            assert_eq!(2, reader.num_read_packets());
459            assert_eq!(0, reader.num_pattern_seeks());
460
461            assert_eq!(
462                reader.next_packet().unwrap().unwrap(),
463                StorageSlice {
464                    storage_header: storage_header1,
465                    packet: DltPacketSlice::from_slice(&packet1).unwrap()
466                }
467            );
468            assert_eq!(3, reader.num_read_packets());
469            assert_eq!(1, reader.num_pattern_seeks());
470
471            assert!(reader.next_packet().is_none());
472        }
473
474        // reader with working packets (strict)
475        {
476            // build two packets
477            let storage_header0 = StorageHeader {
478                timestamp_seconds: 1,
479                timestamp_microseconds: 2,
480                ecu_id: [0, 0, 0, 0],
481            };
482            let packet0 = {
483                let mut packet = Vec::new();
484                let mut header = DltHeader {
485                    is_big_endian: true,
486                    message_counter: 1,
487                    length: 0, // set afterwords
488                    ecu_id: None,
489                    session_id: None,
490                    timestamp: None,
491                    extended_header: None,
492                };
493                header.length = header.header_len() + 4;
494                header.write(&mut packet).unwrap();
495                // set version to 0
496                packet[0] = packet[0] & 0b0001_1111;
497                packet.extend_from_slice(&[1, 2, 3, 4]);
498                packet
499            };
500
501            let storage_header1 = StorageHeader {
502                timestamp_seconds: 3,
503                timestamp_microseconds: 4,
504                ecu_id: [5, 6, 7, 8],
505            };
506            let packet1 = {
507                let mut packet = Vec::new();
508                let mut header = DltHeader {
509                    is_big_endian: true,
510                    message_counter: 2,
511                    length: 0, // set afterwords
512                    ecu_id: None,
513                    session_id: None,
514                    timestamp: None,
515                    extended_header: None,
516                };
517                header.length = header.header_len() + 6;
518                header.write(&mut packet).unwrap();
519                packet.extend_from_slice(&[10, 11, 12, 13, 14, 15]);
520                packet
521            };
522
523            // compose data
524            let mut v = Vec::new();
525            v.extend_from_slice(&storage_header0.to_bytes());
526            v.extend_from_slice(&packet0);
527            v.extend_from_slice(&storage_header1.to_bytes());
528            v.extend_from_slice(&packet1);
529            // add some dummy data to test that an error gets triggered
530            v.extend_from_slice(&[0u8; StorageHeader::BYTE_LEN]);
531
532            // check result
533            let mut reader = DltStorageReader::new_strict(BufReader::new(Cursor::new(&v[..])));
534            assert!(false == reader.is_seeking_storage_pattern());
535            assert_eq!(0, reader.num_read_packets());
536            assert_eq!(0, reader.num_pattern_seeks());
537
538            assert_eq!(
539                reader.next_packet().unwrap().unwrap(),
540                StorageSlice {
541                    storage_header: storage_header0,
542                    packet: DltPacketSlice::from_slice(&packet0).unwrap()
543                }
544            );
545            assert_eq!(1, reader.num_read_packets());
546            assert_eq!(0, reader.num_pattern_seeks());
547
548            assert_eq!(
549                reader.next_packet().unwrap().unwrap(),
550                StorageSlice {
551                    storage_header: storage_header1.clone(),
552                    packet: DltPacketSlice::from_slice(&packet1).unwrap()
553                }
554            );
555            assert_eq!(2, reader.num_read_packets());
556            assert_eq!(0, reader.num_pattern_seeks());
557
558            assert_matches!(
559                reader.next_packet(),
560                Some(Err(ReadError::StorageHeaderStartPattern(_)))
561            );
562
563            assert!(reader.next_packet().is_none());
564        }
565
566        // reader with error during buffering (non seeking)
567        {
568            let mut buf = BufferFillErrorReader {};
569            buf.consume(0);
570            buf.read(&mut []).unwrap();
571
572            let mut reader = DltStorageReader::new(buf);
573            assert_matches!(reader.next_packet(), Some(Err(ReadError::IoError(_))));
574            assert!(reader.next_packet().is_none());
575        }
576
577        // reader with error during buffering (seeking)
578        {
579            let mut buf = BufferFillErrorReader {};
580            buf.consume(0);
581            buf.read(&mut []).unwrap();
582
583            let mut reader = DltStorageReader::new(buf);
584            reader.num_read_packets = 1;
585            assert_matches!(reader.next_packet(), Some(Err(ReadError::IoError(_))));
586            assert!(reader.next_packet().is_none());
587        }
588
589        // storage header read error at start (non seeking)
590        {
591            let bytes = [0u8; StorageHeader::BYTE_LEN - 1];
592            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&bytes[..])));
593            assert!(reader.next_packet().is_none());
594            assert!(reader.next_packet().is_none());
595        }
596
597        // storage header read error at start (seeking)
598        {
599            let mut bytes = [0u8; StorageHeader::BYTE_LEN - 1];
600            bytes[0] = StorageHeader::PATTERN_AT_START[0];
601            bytes[1] = StorageHeader::PATTERN_AT_START[1];
602            bytes[2] = StorageHeader::PATTERN_AT_START[2];
603            bytes[3] = StorageHeader::PATTERN_AT_START[3];
604            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&bytes[..])));
605            reader.num_read_packets = 1;
606            assert!(reader.next_packet().is_none());
607            assert!(reader.next_packet().is_none());
608        }
609
610        // storage header pattern error
611        {
612            let mut bytes = StorageHeader {
613                timestamp_seconds: 0,
614                timestamp_microseconds: 0,
615                ecu_id: [0u8; 4],
616            }
617            .to_bytes();
618            bytes[0] = 0;
619            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&bytes[..])));
620            assert!(reader.next_packet().is_none());
621            assert!(reader.next_packet().is_none());
622        }
623
624        // start read error
625        {
626            let mut v = Vec::new();
627            v.extend_from_slice(
628                &StorageHeader {
629                    timestamp_seconds: 0,
630                    timestamp_microseconds: 0,
631                    ecu_id: [0u8; 4],
632                }
633                .to_bytes(),
634            );
635            v.extend_from_slice(&[1, 2, 3]);
636
637            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&v[..])));
638            assert_matches!(reader.next_packet(), None);
639            assert!(reader.next_packet().is_none());
640        }
641
642        // dlt header version error
643        {
644            let mut v = Vec::new();
645            {
646                v.extend_from_slice(
647                    &StorageHeader {
648                        timestamp_seconds: 1,
649                        timestamp_microseconds: 2,
650                        ecu_id: [0, 0, 0, 0],
651                    }
652                    .to_bytes(),
653                );
654
655                let mut header = DltHeader {
656                    is_big_endian: true,
657                    message_counter: 1,
658                    length: 0, // set afterwords
659                    ecu_id: None,
660                    session_id: None,
661                    timestamp: None,
662                    extended_header: None,
663                };
664                header.length = header.header_len() + 4;
665                header.write(&mut v).unwrap();
666                v.extend_from_slice(&[1, 2, 3, 4]);
667            }
668
669            // change the version to 2
670            v[StorageHeader::BYTE_LEN] = 2 << 5;
671
672            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&v[..])));
673            assert_matches!(reader.next_packet(), None);
674            assert!(reader.next_packet().is_none());
675        }
676
677        // read error of complete packet
678        {
679            let mut v = Vec::new();
680            {
681                v.extend_from_slice(
682                    &StorageHeader {
683                        timestamp_seconds: 1,
684                        timestamp_microseconds: 2,
685                        ecu_id: [0, 0, 0, 0],
686                    }
687                    .to_bytes(),
688                );
689
690                let mut header = DltHeader {
691                    is_big_endian: true,
692                    message_counter: 1,
693                    length: 0, // set afterwords
694                    ecu_id: None,
695                    session_id: None,
696                    timestamp: None,
697                    extended_header: None,
698                };
699                header.length = header.header_len() + 4;
700                header.write(&mut v).unwrap();
701                v.extend_from_slice(&[1, 2, 3]); // missing one byte
702            }
703            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&v[..])));
704            assert!(reader.next_packet().is_none());
705            assert!(reader.next_packet().is_none());
706        }
707
708        // length size error
709        {
710            let mut v = Vec::new();
711            {
712                v.extend_from_slice(
713                    &StorageHeader {
714                        timestamp_seconds: 1,
715                        timestamp_microseconds: 2,
716                        ecu_id: [0, 0, 0, 0],
717                    }
718                    .to_bytes(),
719                );
720
721                DltHeader {
722                    is_big_endian: true,
723                    message_counter: 1,
724                    length: 3, // trigger error
725                    ecu_id: None,
726                    session_id: None,
727                    timestamp: None,
728                    extended_header: None,
729                }
730                .write(&mut v)
731                .unwrap();
732                v.extend_from_slice(&[1, 2, 3]); // missing one byte
733            }
734            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&v[..])));
735            assert!(reader.next_packet().is_none());
736            assert!(reader.next_packet().is_none());
737        }
738
739        // dlt slice error
740        {
741            let mut v = Vec::new();
742            {
743                v.extend_from_slice(
744                    &StorageHeader {
745                        timestamp_seconds: 1,
746                        timestamp_microseconds: 2,
747                        ecu_id: [0, 0, 0, 0],
748                    }
749                    .to_bytes(),
750                );
751
752                // setup a header that needs more then 4 bytes
753                // so the slicing method triggers an error
754                let mut header = DltHeader {
755                    is_big_endian: true,
756                    message_counter: 1,
757                    length: 0, // set later
758                    ecu_id: Some([0u8; 4]),
759                    session_id: Some(1234),
760                    timestamp: None,
761                    extended_header: None,
762                };
763                header.length = header.header_len() - 1;
764                header.write(&mut v).unwrap();
765                v.extend_from_slice(&[]); // missing one byte
766            }
767            let mut reader = DltStorageReader::new(BufReader::new(Cursor::new(&v[..])));
768            assert!(reader.next_packet().is_none());
769            assert!(reader.next_packet().is_none());
770        }
771    }
772}
dlt_parse/storage/dlt_storage_reader.rs

dlt_parse/storage/
dlt_storage_reader.rs
