rust_stdf/
lib.rs

1//! `rust-stdf` is a library for parsing
2//! Standard Test Data Format (STDF) files
3//! of version V4 and V4-2007.
4//!
5//! Current capability:
6//!  - Reading & parsing STDF files.
7//!  - Reading & parsing ATDF files. (feature: `atdf`)
8//!  - Support several compressed formats.
9//!
10//! Available features:
11//!  - `gzip`: gzip compression (.gz) support powered by `flate2`
12//!  - `bzip`: bzip compression (.bz2) support powered by `bzip2`
13//!  - `zipfile`: zip compression (.zip) support powered by `zip`
14//!  - `atdf`: ATDF reader + STDF -> ATDF convertor (in dev)
15//!  - `serialize`: serialize STDF records by `serde`
16//!
17//! In development:
18//!  - (dev) Dump `StdfRecord` to a new stdf file.
19//!  - (dev) Functions for ATDF <-> STDF format.
20
21// lib.rs
22// Author: noonchen - chennoon233@foxmail.com
23// Created Date: October 3rd 2022
24// -----
25// Last Modified: Thu Oct 06 2022
26// Modified By: noonchen
27// -----
28// Copyright (c) 2022 noonchen
29//
30
31extern crate smart_default;
32
33#[cfg(feature = "atdf")]
34mod atdf_types;
35mod stdf_error;
36mod stdf_types;
37pub use stdf_types::*;
38
39/// This module contains STDF Reader
40/// and record iterator
41///
42/// For more detailed example, see [`StdfReader`].
43pub mod stdf_file;
44
45/// This module contains ATDF Reader
46/// and record iterator
47///
48/// For more detailed example, click `AtdfReader`
49#[cfg(feature = "atdf")]
50pub mod atdf_file;
51
52#[cfg(test)]
53mod tests {
54    use crate::*;
55    use stdf_types::ByteOrder;
56
57    // unsigned data type
58    #[test]
59    fn test_read_uint8() {
60        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
61        for i in 0..raw_data.len() {
62            let mut pos = i;
63            assert_eq!(raw_data[pos], stdf_types::read_uint8(&raw_data, &mut pos));
64            assert_eq!(pos, i + 1);
65        }
66        let mut pos = raw_data.len();
67        assert_eq!(0, stdf_types::read_uint8(&raw_data, &mut pos));
68        assert_eq!(pos, raw_data.len());
69    }
70
71    #[test]
72    fn test_read_u2_le() {
73        let byte_len = 2;
74        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
75        let expect = [0x0201, 0x0302, 0x0403, 0x0504, 0x0605, 0x0706, 0x0807, 0u16];
76        let order = ByteOrder::LittleEndian;
77        for i in 0..raw_data.len() {
78            let mut pos = i;
79            assert_eq!(
80                expect[pos],
81                stdf_types::read_u2(&raw_data, &mut pos, &order)
82            );
83
84            if i <= raw_data.len() - byte_len {
85                assert_eq!(pos, i + byte_len);
86            } else {
87                assert_eq!(pos, i);
88            }
89        }
90        let mut pos = raw_data.len();
91        assert_eq!(0, stdf_types::read_u2(&raw_data, &mut pos, &order));
92        assert_eq!(pos, raw_data.len());
93    }
94
95    #[test]
96    fn test_read_u2_be() {
97        let byte_len = 2;
98        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
99        let expect = [0x0102, 0x0203, 0x0304, 0x0405, 0x0506, 0x0607, 0x0708, 0u16];
100        let order = ByteOrder::BigEndian;
101        for i in 0..raw_data.len() {
102            let mut pos = i;
103            assert_eq!(
104                expect[pos],
105                stdf_types::read_u2(&raw_data, &mut pos, &order)
106            );
107
108            if i <= raw_data.len() - byte_len {
109                assert_eq!(pos, i + byte_len);
110            } else {
111                assert_eq!(pos, i);
112            }
113        }
114        let mut pos = raw_data.len();
115        assert_eq!(0, stdf_types::read_u2(&raw_data, &mut pos, &order));
116        assert_eq!(pos, raw_data.len());
117    }
118
119    #[test]
120    fn test_read_u4_le() {
121        let byte_len = 4;
122        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
123        let expect = [
124            0x4030201, 0x5040302, 0x6050403, 0x7060504, 0x8070605, 0, 0, 0u32,
125        ];
126        let order = ByteOrder::LittleEndian;
127        for i in 0..raw_data.len() {
128            let mut pos = i;
129            assert_eq!(
130                expect[pos],
131                stdf_types::read_u4(&raw_data, &mut pos, &order)
132            );
133
134            if i <= raw_data.len() - byte_len {
135                assert_eq!(pos, i + byte_len);
136            } else {
137                assert_eq!(pos, i);
138            }
139        }
140        let mut pos = raw_data.len();
141        assert_eq!(0, stdf_types::read_u4(&raw_data, &mut pos, &order));
142        assert_eq!(pos, raw_data.len());
143    }
144
145    #[test]
146    fn test_read_u4_be() {
147        let byte_len = 4;
148        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
149        let expect = [
150            0x1020304, 0x2030405, 0x3040506, 0x4050607, 0x5060708, 0, 0, 0u32,
151        ];
152        let order = ByteOrder::BigEndian;
153        for i in 0..raw_data.len() {
154            let mut pos = i;
155            assert_eq!(
156                expect[pos],
157                stdf_types::read_u4(&raw_data, &mut pos, &order)
158            );
159
160            if i <= raw_data.len() - byte_len {
161                assert_eq!(pos, i + byte_len);
162            } else {
163                assert_eq!(pos, i);
164            }
165        }
166        let mut pos = raw_data.len();
167        assert_eq!(0, stdf_types::read_u4(&raw_data, &mut pos, &order));
168        assert_eq!(pos, raw_data.len());
169    }
170
171    #[test]
172    fn test_read_u8_le() {
173        let byte_len = 8;
174        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8];
175        let expect = [0x807060504030201, 0x908070605040302, 0, 0, 0, 0, 0, 0, 0u64];
176        let order = ByteOrder::LittleEndian;
177        for i in 0..raw_data.len() {
178            let mut pos = i;
179            assert_eq!(
180                expect[pos],
181                stdf_types::read_u8(&raw_data, &mut pos, &order)
182            );
183
184            if i <= raw_data.len() - byte_len {
185                assert_eq!(pos, i + byte_len);
186            } else {
187                assert_eq!(pos, i);
188            }
189        }
190        let mut pos = raw_data.len();
191        assert_eq!(0, stdf_types::read_u8(&raw_data, &mut pos, &order));
192        assert_eq!(pos, raw_data.len());
193    }
194
195    #[test]
196    fn test_read_u8_be() {
197        let byte_len = 8;
198        let raw_data = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8];
199        let expect = [0x102030405060708, 0x203040506070809, 0, 0, 0, 0, 0, 0, 0u64];
200        let order = ByteOrder::BigEndian;
201        for i in 0..raw_data.len() {
202            let mut pos = i;
203            assert_eq!(
204                expect[pos],
205                stdf_types::read_u8(&raw_data, &mut pos, &order)
206            );
207
208            if i <= raw_data.len() - byte_len {
209                assert_eq!(pos, i + byte_len);
210            } else {
211                assert_eq!(pos, i);
212            }
213        }
214        let mut pos = raw_data.len();
215        assert_eq!(0, stdf_types::read_u8(&raw_data, &mut pos, &order));
216        assert_eq!(pos, raw_data.len());
217    }
218
219    // signed data type
220    #[test]
221    fn test_read_i1() {
222        let raw_data: [u8; 8] = [0x00, 0x01, 0x7F, 0xFE, 0x80, 0x81, 0x8F, 0xFF];
223        let expected: [i8; 8] = [0, 1, 127, -2, -128, -127, -113, -1];
224        for i in 0..raw_data.len() {
225            let mut pos = i;
226            assert_eq!(expected[pos], stdf_types::read_i1(&raw_data, &mut pos));
227            assert_eq!(pos, i + 1);
228        }
229        let mut pos = raw_data.len();
230        assert_eq!(0, stdf_types::read_uint8(&raw_data, &mut pos));
231        assert_eq!(pos, raw_data.len());
232    }
233
234    #[test]
235    fn test_read_i2_le() {
236        let byte_len = 2;
237        let raw_data: [u8; 8] = [0x00, 0x01, 0x7F, 0xFE, 0x80, 0x81, 0x8F, 0xFF];
238        let expected: [i16; 8] = [0x100, 0x7F01, -385, -32514, -32384, -28799, -113, 0];
239        let order = ByteOrder::LittleEndian;
240        for i in 0..raw_data.len() {
241            let mut pos = i;
242            assert_eq!(
243                expected[pos],
244                stdf_types::read_i2(&raw_data, &mut pos, &order)
245            );
246
247            if i <= raw_data.len() - byte_len {
248                assert_eq!(pos, i + byte_len);
249            } else {
250                assert_eq!(pos, i);
251            }
252        }
253        let mut pos = raw_data.len();
254        assert_eq!(0, stdf_types::read_i2(&raw_data, &mut pos, &order));
255        assert_eq!(pos, raw_data.len());
256    }
257
258    #[test]
259    fn test_read_i2_be() {
260        let byte_len = 2;
261        let raw_data: [u8; 8] = [0x00, 0x01, 0x7F, 0xFE, 0x80, 0x81, 0x8F, 0xFF];
262        let expected: [i16; 8] = [0x1, 0x17F, 0x7FFE, -384, -32639, -32369, -28673, 0];
263        let order = ByteOrder::BigEndian;
264        for i in 0..raw_data.len() {
265            let mut pos = i;
266            assert_eq!(
267                expected[pos],
268                stdf_types::read_i2(&raw_data, &mut pos, &order)
269            );
270
271            if i <= raw_data.len() - byte_len {
272                assert_eq!(pos, i + byte_len);
273            } else {
274                assert_eq!(pos, i);
275            }
276        }
277        let mut pos = raw_data.len();
278        assert_eq!(0, stdf_types::read_i2(&raw_data, &mut pos, &order));
279        assert_eq!(pos, raw_data.len());
280    }
281
282    #[test]
283    fn test_read_i4_le() {
284        let byte_len = 4;
285        let raw_data: [u8; 8] = [0x00, 0x01, 0x7F, 0xFE, 0x80, 0x81, 0x8F, 0xFF];
286        let expected: [i32; 8] = [
287            -25231104,
288            -2130804991,
289            -2122252673,
290            -1887338242,
291            -7372416,
292            0,
293            0,
294            0,
295        ];
296        let order = ByteOrder::LittleEndian;
297        for i in 0..raw_data.len() {
298            let mut pos = i;
299            assert_eq!(
300                expected[pos],
301                stdf_types::read_i4(&raw_data, &mut pos, &order)
302            );
303
304            if i <= raw_data.len() - byte_len {
305                assert_eq!(pos, i + byte_len);
306            } else {
307                assert_eq!(pos, i);
308            }
309        }
310        let mut pos = raw_data.len();
311        assert_eq!(0, stdf_types::read_i4(&raw_data, &mut pos, &order));
312        assert_eq!(pos, raw_data.len());
313    }
314
315    #[test]
316    fn test_read_i4_be() {
317        let byte_len = 4;
318        let raw_data: [u8; 8] = [0x00, 0x01, 0x7F, 0xFE, 0x80, 0x81, 0x8F, 0xFF];
319        let expected: [i32; 8] = [
320            0x17FFE,
321            0x17FFE80,
322            0x7FFE8081,
323            -25132657,
324            -2138992641,
325            0,
326            0,
327            0,
328        ];
329        let order = ByteOrder::BigEndian;
330        for i in 0..raw_data.len() {
331            let mut pos = i;
332            assert_eq!(
333                expected[pos],
334                stdf_types::read_i4(&raw_data, &mut pos, &order)
335            );
336
337            if i <= raw_data.len() - byte_len {
338                assert_eq!(pos, i + byte_len);
339            } else {
340                assert_eq!(pos, i);
341            }
342        }
343        let mut pos = raw_data.len();
344        assert_eq!(0, stdf_types::read_i4(&raw_data, &mut pos, &order));
345        assert_eq!(pos, raw_data.len());
346    }
347
348    // float
349    #[test]
350    fn test_read_r4_le() {
351        let byte_len = 4;
352        let raw_data: [u8; 8] = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
353        let expected: [f32; 8] = [
354            1.5399896e-36,
355            6.2071626e-36,
356            2.5017467e-35,
357            1.0082514e-34,
358            4.063216e-34,
359            0.0,
360            0.0,
361            0.0,
362        ];
363        let order = ByteOrder::LittleEndian;
364        for i in 0..raw_data.len() {
365            let mut pos = i;
366            assert_eq!(
367                expected[pos],
368                stdf_types::read_r4(&raw_data, &mut pos, &order)
369            );
370
371            if i <= raw_data.len() - byte_len {
372                assert_eq!(pos, i + byte_len);
373            } else {
374                assert_eq!(pos, i);
375            }
376        }
377        let mut pos = raw_data.len();
378        assert_eq!(0.0, stdf_types::read_r4(&raw_data, &mut pos, &order));
379        assert_eq!(pos, raw_data.len());
380    }
381
382    #[test]
383    fn test_read_r4_be() {
384        let byte_len = 4;
385        let raw_data: [u8; 8] = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8];
386        let expected: [f32; 8] = [
387            2.3879393e-38,
388            9.625514e-38,
389            3.879708e-37,
390            1.5636842e-36,
391            6.301941e-36,
392            0.0,
393            0.0,
394            0.0,
395        ];
396        let order = ByteOrder::BigEndian;
397        for i in 0..raw_data.len() {
398            let mut pos = i;
399            assert_eq!(
400                expected[pos],
401                stdf_types::read_r4(&raw_data, &mut pos, &order)
402            );
403
404            if i <= raw_data.len() - byte_len {
405                assert_eq!(pos, i + byte_len);
406            } else {
407                assert_eq!(pos, i);
408            }
409        }
410        let mut pos = raw_data.len();
411        assert_eq!(0.0, stdf_types::read_r4(&raw_data, &mut pos, &order));
412        assert_eq!(pos, raw_data.len());
413    }
414
415    #[test]
416    fn test_read_r8_le() {
417        let byte_len = 8;
418        let raw_data: [u8; 9] = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8];
419        let expected: [f64; 9] = [
420            5.447603722011605e-270,
421            3.7258146895053074e-265,
422            0.0,
423            0.0,
424            0.0,
425            0.0,
426            0.0,
427            0.0,
428            0.0,
429        ];
430        let order = ByteOrder::LittleEndian;
431        for i in 0..raw_data.len() {
432            let mut pos = i;
433            assert_eq!(
434                expected[pos],
435                stdf_types::read_r8(&raw_data, &mut pos, &order)
436            );
437
438            if i <= raw_data.len() - byte_len {
439                assert_eq!(pos, i + byte_len);
440            } else {
441                assert_eq!(pos, i);
442            }
443        }
444        let mut pos = raw_data.len();
445        assert_eq!(0.0, stdf_types::read_r8(&raw_data, &mut pos, &order));
446        assert_eq!(pos, raw_data.len());
447    }
448
449    #[test]
450    fn test_read_r8_be() {
451        let byte_len = 8;
452        let raw_data: [u8; 9] = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8];
453        let expected: [f64; 9] = [
454            8.20788039913184e-304,
455            5.678932010640861e-299,
456            0.0,
457            0.0,
458            0.0,
459            0.0,
460            0.0,
461            0.0,
462            0.0,
463        ];
464        let order = ByteOrder::BigEndian;
465        for i in 0..raw_data.len() {
466            let mut pos = i;
467            assert_eq!(
468                expected[pos],
469                stdf_types::read_r8(&raw_data, &mut pos, &order)
470            );
471
472            if i <= raw_data.len() - byte_len {
473                assert_eq!(pos, i + byte_len);
474            } else {
475                assert_eq!(pos, i);
476            }
477        }
478        let mut pos = raw_data.len();
479        assert_eq!(0.0, stdf_types::read_r8(&raw_data, &mut pos, &order));
480        assert_eq!(pos, raw_data.len());
481    }
482
483    // string & array
484    #[test]
485    fn test_read_cn() {
486        let raw_data: [u8; 9] = [7, 84, 101, 115, 116, 32, 79, 75, 0];
487        let mut pos = 0;
488        let expect_pos = |p: usize| std::cmp::min(1 + p + raw_data[p] as usize, raw_data.len());
489        assert_eq!(
490            "Test OK".to_string(),
491            stdf_types::read_cn(&raw_data, &mut pos)
492        );
493        assert_eq!(pos, expect_pos(0));
494        let mut pos = 4;
495        assert_eq!(
496            " OK\0".to_string(),
497            stdf_types::read_cn(&raw_data, &mut pos)
498        );
499        assert_eq!(pos, expect_pos(4));
500        let mut pos = 8;
501        assert_eq!("".to_string(), stdf_types::read_cn(&raw_data, &mut pos));
502        assert_eq!(pos, expect_pos(8));
503        // latin1 check
504        let raw_data_latin: [u8; 7] = [6, 52, 50, 176, 67, 191, 255];
505        assert_eq!(
506            "42°C¿ÿ".to_string(),
507            stdf_types::read_cn(&raw_data_latin, &mut 0)
508        );
509    }
510
511    #[test]
512    fn test_read_sn_le() {
513        let raw_data: [u8; 10] = [7, 0, 84, 101, 115, 116, 32, 79, 75, 0];
514        let mut pos = 0;
515        let order = ByteOrder::LittleEndian;
516        assert_eq!(
517            "Test OK".to_string(),
518            stdf_types::read_sn(&raw_data, &mut pos, &order)
519        );
520        assert_eq!(pos, 9);
521        let mut pos = 4;
522        assert_eq!(
523            " OK\0".to_string(),
524            stdf_types::read_sn(&raw_data, &mut pos, &order)
525        );
526        assert_eq!(pos, 10);
527        let mut pos = 9;
528        assert_eq!(
529            "".to_string(),
530            stdf_types::read_sn(&raw_data, &mut pos, &order)
531        );
532        assert_eq!(pos, 9);
533    }
534
535    #[test]
536    fn test_read_sn_be() {
537        let raw_data: [u8; 10] = [0, 7, 84, 101, 115, 116, 32, 79, 75, 0];
538        let mut pos = 0;
539        let order = ByteOrder::BigEndian;
540        assert_eq!(
541            "Test OK".to_string(),
542            stdf_types::read_sn(&raw_data, &mut pos, &order)
543        );
544        assert_eq!(pos, 9);
545        let mut pos = 4;
546        assert_eq!(
547            " OK\0".to_string(),
548            stdf_types::read_sn(&raw_data, &mut pos, &order)
549        );
550        assert_eq!(pos, 10);
551        let mut pos = 9;
552        assert_eq!(
553            "".to_string(),
554            stdf_types::read_sn(&raw_data, &mut pos, &order)
555        );
556        assert_eq!(pos, 9);
557    }
558
559    #[test]
560    fn test_read_cf() {
561        let raw_data: [u8; 9] = [7, 84, 101, 115, 116, 32, 79, 75, 0];
562        let mut pos = 1;
563        assert_eq!(
564            "Test OK".to_string(),
565            stdf_types::read_cf(&raw_data, &mut pos, 7)
566        );
567        assert_eq!(pos, 8);
568        let mut pos = 5;
569        assert_eq!(
570            " OK\0".to_string(),
571            stdf_types::read_cf(&raw_data, &mut pos, 100)
572        );
573        assert_eq!(pos, 9);
574        let mut pos = 8;
575        assert_eq!("".to_string(), stdf_types::read_cf(&raw_data, &mut pos, 0));
576        assert_eq!(pos, 8);
577    }
578
579    #[test]
580    fn test_read_bn() {
581        let raw_data: [u8; 9] = [7, 84, 101, 115, 116, 32, 79, 75, 0];
582        let mut pos = 0;
583        assert_eq!(
584            vec![84, 101, 115, 116, 32, 79, 75],
585            stdf_types::read_bn(&raw_data, &mut pos)
586        );
587        assert_eq!(pos, 8);
588        let mut pos = 4;
589        assert_eq!(
590            vec![32, 79, 75, 0],
591            stdf_types::read_bn(&raw_data, &mut pos)
592        );
593        assert_eq!(pos, 9);
594        let mut pos = 100;
595        assert_eq!(vec![0u8; 0], stdf_types::read_bn(&raw_data, &mut pos));
596        assert_eq!(pos, 100);
597    }
598
599    #[test]
600    fn test_read_dn() {
601        let raw_data: [u8; 10] = [56, 0, 84, 101, 115, 116, 32, 79, 75, 0];
602        let mut pos = 0;
603        let order = ByteOrder::LittleEndian;
604        assert_eq!(
605            vec![84, 101, 115, 116, 32, 79, 75],
606            stdf_types::read_dn(&raw_data, &mut pos, &order)
607        );
608        assert_eq!(pos, 9);
609        let mut pos = 4;
610        assert_eq!(
611            vec![32, 79, 75, 0],
612            stdf_types::read_dn(&raw_data, &mut pos, &order)
613        );
614        assert_eq!(pos, 10);
615        let mut pos = 100;
616        assert_eq!(
617            vec![0u8; 0],
618            stdf_types::read_dn(&raw_data, &mut pos, &order)
619        );
620        assert_eq!(pos, 100);
621    }
622
623    // Vec
624    #[test]
625    fn test_read_kx_cn() {
626        let raw_data: [u8; 12] = [2, 84, 101, 2, 115, 116, 1, 32, 2, 79, 75, 0];
627        let mut pos = 0;
628        assert_eq!(
629            vec![
630                "Te".to_string(),
631                "st".to_string(),
632                " ".to_string(),
633                "OK".to_string()
634            ],
635            stdf_types::read_kx_cn(&raw_data, &mut pos, 4)
636        );
637        assert_eq!(pos, 11);
638        let mut pos = 3;
639        assert_eq!(
640            vec![
641                "st".to_string(),
642                " ".to_string(),
643                "OK".to_string(),
644                "".to_string()
645            ],
646            stdf_types::read_kx_cn(&raw_data, &mut pos, 4)
647        );
648        assert_eq!(pos, 12);
649        assert_eq!(
650            vec!["".to_string(); 0],
651            stdf_types::read_kx_cn(&raw_data, &mut pos, 0)
652        );
653    }
654
655    #[test]
656    fn test_read_kx_sn() {
657        let raw_data: [u8; 16] = [2, 0, 84, 101, 2, 0, 115, 116, 1, 0, 32, 2, 0, 79, 75, 0];
658        let mut pos = 0;
659        let order = ByteOrder::LittleEndian;
660        assert_eq!(
661            vec![
662                "Te".to_string(),
663                "st".to_string(),
664                " ".to_string(),
665                "OK".to_string()
666            ],
667            stdf_types::read_kx_sn(&raw_data, &mut pos, &order, 4)
668        );
669        assert_eq!(pos, 15);
670        let mut pos = 4;
671        assert_eq!(
672            vec![
673                "st".to_string(),
674                " ".to_string(),
675                "OK".to_string(),
676                "".to_string()
677            ],
678            stdf_types::read_kx_sn(&raw_data, &mut pos, &order, 4)
679        );
680        assert_eq!(pos, 15);
681        assert_eq!(
682            vec!["".to_string(); 0],
683            stdf_types::read_kx_sn(&raw_data, &mut pos, &order, 0)
684        );
685    }
686
687    #[test]
688    fn test_read_kx_cf() {
689        let raw_data: [u8; 9] = [84, 101, 115, 116, 32, 32, 79, 75, 0];
690        let mut pos = 0;
691        assert_eq!(
692            vec![
693                "Te".to_string(),
694                "st".to_string(),
695                "  ".to_string(),
696                "OK".to_string()
697            ],
698            stdf_types::read_kx_cf(&raw_data, &mut pos, 4, 2)
699        );
700        assert_eq!(pos, 8);
701        let mut pos = 3;
702        assert_eq!(
703            vec![
704                "".to_string(),
705                "".to_string(),
706                "".to_string(),
707                "".to_string()
708            ],
709            stdf_types::read_kx_cf(&raw_data, &mut pos, 4, 0)
710        );
711        assert_eq!(pos, 3);
712    }
713
714    #[test]
715    fn test_read_kx_u1() {
716        let raw_data: [u8; 9] = [84, 101, 115, 116, 32, 32, 79, 75, 0];
717        let mut pos = 0;
718        assert_eq!(
719            vec![84, 101, 115, 116, 32, 32, 79, 75, 0],
720            stdf_types::read_kx_u1(&raw_data, &mut pos, 9)
721        );
722        assert_eq!(pos, 9);
723        let mut pos = 3;
724        assert_eq!(vec![0u8; 0], stdf_types::read_kx_u1(&raw_data, &mut pos, 0));
725        assert_eq!(pos, 3);
726    }
727
728    #[test]
729    fn test_read_kx_u2() {
730        let raw_data: [u8; 9] = [0x12, 0x23, 0x45, 0x78, 0x9A, 0xBC, 0xDE, 0xFF, 0];
731        let mut pos = 0;
732        let order = ByteOrder::LittleEndian;
733        assert_eq!(
734            vec![0x2312, 0x7845, 0xBC9A, 0xFFDE, 0],
735            stdf_types::read_kx_u2(&raw_data, &mut pos, &order, 5)
736        );
737        assert_eq!(pos, 8);
738        let mut pos = 3;
739        assert_eq!(
740            vec![0u16; 0],
741            stdf_types::read_kx_u2(&raw_data, &mut pos, &order, 0)
742        );
743        assert_eq!(pos, 3);
744    }
745
746    #[test]
747    fn test_read_kx_u4() {
748        let raw_data: [u8; 9] = [0x12, 0x23, 0x45, 0x78, 0x9A, 0xBC, 0xDE, 0xFF, 0];
749        let mut pos = 0;
750        let order = ByteOrder::LittleEndian;
751        assert_eq!(
752            vec![0x78452312, 0xFFDEBC9A, 0, 0, 0],
753            stdf_types::read_kx_u4(&raw_data, &mut pos, &order, 5)
754        );
755        assert_eq!(pos, 8);
756        let mut pos = 3;
757        assert_eq!(
758            vec![0u32; 0],
759            stdf_types::read_kx_u4(&raw_data, &mut pos, &order, 0)
760        );
761        assert_eq!(pos, 3);
762    }
763
764    #[test]
765    fn test_read_kx_u8() {
766        let raw_data: [u8; 9] = [0x12, 0x23, 0x45, 0x78, 0x9A, 0xBC, 0xDE, 0xFF, 0];
767        let mut pos = 0;
768        let order = ByteOrder::LittleEndian;
769        assert_eq!(
770            vec![0xFFDEBC9A78452312, 0, 0, 0, 0],
771            stdf_types::read_kx_u8(&raw_data, &mut pos, &order, 5)
772        );
773        assert_eq!(pos, 8);
774        let mut pos = 3;
775        assert_eq!(
776            vec![0u64; 0],
777            stdf_types::read_kx_u8(&raw_data, &mut pos, &order, 0)
778        );
779        assert_eq!(pos, 3);
780    }
781
782    #[test]
783    fn test_read_kx_uf() {
784        let raw_data: [u8; 9] = [0x12, 0x23, 0x45, 0x78, 0x9A, 0xBC, 0xDE, 0xFF, 0];
785        let mut pos = 0;
786        let order = ByteOrder::LittleEndian;
787        assert_eq!(
788            stdf_types::KxUf::F1(vec![0x12, 0x23, 0x45, 0x78, 0x9A]),
789            stdf_types::read_kx_uf(&raw_data, &mut pos, &order, 5, 1)
790        );
791        assert_eq!(pos, 5);
792        let mut pos = 0;
793        assert_eq!(
794            stdf_types::KxUf::F2(vec![0x2312, 0x7845, 0xBC9A, 0xFFDE, 0]),
795            stdf_types::read_kx_uf(&raw_data, &mut pos, &order, 5, 2)
796        );
797        assert_eq!(pos, 8);
798        let mut pos = 0;
799        assert_eq!(
800            stdf_types::KxUf::F4(vec![0x78452312, 0xFFDEBC9A, 0, 0, 0]),
801            stdf_types::read_kx_uf(&raw_data, &mut pos, &order, 5, 4)
802        );
803        assert_eq!(pos, 8);
804        let mut pos = 0;
805        assert_eq!(
806            stdf_types::KxUf::F8(vec![0xFFDEBC9A78452312, 0, 0, 0, 0]),
807            stdf_types::read_kx_uf(&raw_data, &mut pos, &order, 5, 8)
808        );
809        assert_eq!(pos, 8);
810        let mut pos = 3;
811        assert_eq!(
812            stdf_types::KxUf::F1(vec![0u8; 0]),
813            stdf_types::read_kx_uf(&raw_data, &mut pos, &order, 100, 0)
814        );
815        assert_eq!(pos, 3);
816    }
817
818    #[test]
819    fn test_read_kx_r4() {
820        let raw_data: [u8; 9] = [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 0];
821        let mut pos = 0;
822        let order = ByteOrder::LittleEndian;
823        assert_eq!(
824            vec![1.5399896e-36, 4.063216e-34, 0.0, 0.0, 0.0],
825            stdf_types::read_kx_r4(&raw_data, &mut pos, &order, 5)
826        );
827        assert_eq!(pos, 8);
828        let mut pos = 3;
829        assert_eq!(
830            vec![0.0; 0],
831            stdf_types::read_kx_r4(&raw_data, &mut pos, &order, 0)
832        );
833        assert_eq!(pos, 3);
834    }
835
836    #[test]
837    fn test_read_kx_n1() {
838        let raw_data: [u8; 9] = [0x12, 0x23, 0x45, 0x78, 0x9A, 0xBC, 0xDE, 0xFF, 0];
839        let mut pos = 0;
840        assert_eq!(
841            vec![0x2, 0x1, 0x3, 0x2, 0x5],
842            stdf_types::read_kx_n1(&raw_data, &mut pos, 5)
843        );
844        assert_eq!(pos, 3);
845        let mut pos = 3;
846        assert_eq!(vec![0u8; 0], stdf_types::read_kx_n1(&raw_data, &mut pos, 0));
847        assert_eq!(pos, 3);
848    }
849
850    // generic data
851    #[test]
852    fn test_read_vn() {
853        let raw_data: [u8; 14] = [
854            0x4, 0x0, 0xA, 0x2, 0x41, 0x42, 0x1, 0xFF, 0x0, 0x5, 0xFE, 0x1, 0xD, 0x45,
855        ];
856        let mut pos = 2;
857        let order = ByteOrder::LittleEndian;
858        assert_eq!(
859            vec![
860                stdf_types::V1::Cn("AB".to_string()),
861                stdf_types::V1::U1(0xFF),
862                stdf_types::V1::B0,
863                stdf_types::V1::I2(510),
864                stdf_types::V1::N1(0x5),
865            ],
866            stdf_types::read_vn(&raw_data, &mut pos, &order, 5)
867        );
868        assert_eq!(pos, 14);
869        let mut pos = 3;
870        assert_eq!(
871            vec![stdf_types::V1::Invalid; 0],
872            stdf_types::read_vn(&raw_data, &mut pos, &order, 0)
873        );
874        assert_eq!(pos, 3);
875    }
876
877    #[test]
878    fn test_record_type() {
879        for rec_type in (0..=33).map(|x| 1 << x) {
880            assert!(
881                StdfRecord::new(rec_type).is_type(rec_type),
882                "match type incorrect"
883            );
884        }
885    }
886
887    #[cfg(feature = "atdf")]
888    use atdf_types::atdf_record_field::*;
889
890    #[cfg(feature = "atdf")]
891    #[test]
892    fn test_atdf_fields_duplicate() {
893        use std::collections::HashMap;
894        let find_dup = |arr: &[(&str, bool)], name: &str| {
895            arr.iter()
896                // .copied()
897                .fold(HashMap::new(), |mut map, val| {
898                    map.entry(val.0).and_modify(|frq| *frq += 1).or_insert(1);
899                    map
900                })
901                .iter()
902                .map(|(s, &n)| assert_eq!(n, 1, "dup field {} in {}", s, name))
903                .count()
904        };
905
906        find_dup(&FAR_FIELD, "FAR");
907        find_dup(&ATR_FIELD, "ATR");
908        find_dup(&MIR_FIELD, "MIR");
909        find_dup(&MRR_FIELD, "MRR");
910        find_dup(&PCR_FIELD, "PCR");
911        find_dup(&HBR_FIELD, "HBR");
912        find_dup(&SBR_FIELD, "SBR");
913        find_dup(&PMR_FIELD, "PMR");
914        find_dup(&PGR_FIELD, "PGR");
915        find_dup(&PLR_FIELD, "PLR");
916        find_dup(&RDR_FIELD, "RDR");
917        find_dup(&SDR_FIELD, "SDR");
918        find_dup(&WIR_FIELD, "WIR");
919        find_dup(&WRR_FIELD, "WRR");
920        find_dup(&WCR_FIELD, "WCR");
921        find_dup(&PIR_FIELD, "PIR");
922        find_dup(&PRR_FIELD, "PRR");
923        find_dup(&TSR_FIELD, "TSR");
924        find_dup(&PTR_FIELD, "PTR");
925        find_dup(&MPR_FIELD, "MPR");
926        find_dup(&FTR_FIELD, "FTR");
927        find_dup(&BPS_FIELD, "BPS");
928        find_dup(&EPS_FIELD, "EPS");
929        find_dup(&GDR_FIELD, "GDR");
930        find_dup(&DTR_FIELD, "DTR");
931    }
932
933    #[cfg(feature = "atdf")]
934    #[test]
935    fn test_atdf_field_req_count() {
936        assert_eq!(3, atdf_types::count_reqired(&PTR_FIELD));
937        assert_eq!(0, atdf_types::count_reqired(&GDR_FIELD));
938    }
939}
rust_stdf/lib.rs

rust_stdf/
lib.rs
