ads_proto/proto/
request.rs

1use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
2use std::io::{self, Read, Write};
3
4use crate::error::TryIntoError;
5use crate::proto::ads_state::AdsState;
6use crate::proto::ads_transition_mode::AdsTransMode;
7use crate::proto::command_id::CommandID;
8use crate::proto::proto_traits::{Command, ReadFrom, WriteTo};
9use std::convert::TryInto;
10
11/// Each Request enum variant holds the struct with the data needed for a certain command.
12/// The created Request can then be supplied to an [AMS header](super::ams_header).
13/// ```
14/// use crate::ads_proto::proto::request::*;
15/// use crate::ads_proto::proto::proto_traits::{ReadFrom, WriteTo};
16///
17/// let request = Request::ReadDeviceInfo(ReadDeviceInfoRequest::new());
18/// ```
19#[derive(Debug, PartialEq, Eq, Clone)]
20pub enum Request {
21    Invalid(InvalidRequest),
22    ReadDeviceInfo(ReadDeviceInfoRequest),
23    ReadState(ReadStateRequest),
24    Read(ReadRequest),
25    Write(WriteRequest),
26    WriteControl(WriteControlRequest),
27    AddDeviceNotification(AddDeviceNotificationRequest),
28    DeleteDeviceNotification(DeleteDeviceNotificationRequest),
29    DeviceNotification(DeviceNotificationRequest),
30    ReadWrite(ReadWriteRequest),
31}
32
33impl WriteTo for Request {
34    fn write_to<W: Write>(&self, wtr: W) -> io::Result<()> {
35        match self {
36            Request::Invalid(_) => Ok(()),
37            Request::ReadDeviceInfo(_) => Ok(()),
38            Request::ReadState(_) => Ok(()),
39            Request::Read(r) => r.write_to(wtr),
40            Request::Write(r) => r.write_to(wtr),
41            Request::ReadWrite(r) => r.write_to(wtr),
42            Request::AddDeviceNotification(r) => r.write_to(wtr),
43            Request::WriteControl(r) => r.write_to(wtr),
44            Request::DeviceNotification(_) => Ok(()),
45            Request::DeleteDeviceNotification(r) => r.write_to(wtr),
46        }
47    }
48}
49
50impl Command for Request {
51    fn command_id(&self) -> CommandID {
52        match self {
53            Request::Invalid(r) => r.command_id,
54            Request::ReadDeviceInfo(r) => r.command_id,
55            Request::ReadState(r) => r.command_id,
56            Request::Read(r) => r.command_id,
57            Request::Write(r) => r.command_id,
58            Request::ReadWrite(r) => r.command_id,
59            Request::AddDeviceNotification(r) => r.command_id,
60            Request::WriteControl(r) => r.command_id,
61            Request::DeviceNotification(r) => r.command_id,
62            Request::DeleteDeviceNotification(r) => r.command_id,
63        }
64    }
65}
66
67impl From<InvalidRequest> for Request {
68    fn from(request: InvalidRequest) -> Self {
69        Request::Invalid(request)
70    }
71}
72
73impl TryInto<InvalidRequest> for Request {
74    type Error = TryIntoError;
75
76    fn try_into(self) -> Result<InvalidRequest, Self::Error> {
77        match self {
78            Request::Invalid(r) => Ok(r),
79            _ => Err(TryIntoError::TryIntoRequestFailed),
80        }
81    }
82}
83
84impl From<ReadDeviceInfoRequest> for Request {
85    fn from(request: ReadDeviceInfoRequest) -> Self {
86        Request::ReadDeviceInfo(request)
87    }
88}
89
90impl TryInto<ReadDeviceInfoRequest> for Request {
91    type Error = TryIntoError;
92
93    fn try_into(self) -> Result<ReadDeviceInfoRequest, Self::Error> {
94        match self {
95            Request::ReadDeviceInfo(r) => Ok(r),
96            _ => Err(TryIntoError::TryIntoRequestFailed),
97        }
98    }
99}
100
101impl From<ReadStateRequest> for Request {
102    fn from(request: ReadStateRequest) -> Self {
103        Request::ReadState(request)
104    }
105}
106
107impl TryInto<ReadStateRequest> for Request {
108    type Error = TryIntoError;
109
110    fn try_into(self) -> Result<ReadStateRequest, Self::Error> {
111        match self {
112            Request::ReadState(r) => Ok(r),
113            _ => Err(TryIntoError::TryIntoRequestFailed),
114        }
115    }
116}
117
118impl From<ReadRequest> for Request {
119    fn from(request: ReadRequest) -> Self {
120        Request::Read(request)
121    }
122}
123
124impl TryInto<ReadRequest> for Request {
125    type Error = TryIntoError;
126
127    fn try_into(self) -> Result<ReadRequest, Self::Error> {
128        match self {
129            Request::Read(r) => Ok(r),
130            _ => Err(TryIntoError::TryIntoRequestFailed),
131        }
132    }
133}
134
135impl From<WriteRequest> for Request {
136    fn from(request: WriteRequest) -> Self {
137        Request::Write(request)
138    }
139}
140
141impl TryInto<WriteRequest> for Request {
142    type Error = TryIntoError;
143
144    fn try_into(self) -> Result<WriteRequest, Self::Error> {
145        match self {
146            Request::Write(r) => Ok(r),
147            _ => Err(TryIntoError::TryIntoRequestFailed),
148        }
149    }
150}
151
152impl From<WriteControlRequest> for Request {
153    fn from(request: WriteControlRequest) -> Self {
154        Request::WriteControl(request)
155    }
156}
157
158impl TryInto<WriteControlRequest> for Request {
159    type Error = TryIntoError;
160
161    fn try_into(self) -> Result<WriteControlRequest, Self::Error> {
162        match self {
163            Request::WriteControl(r) => Ok(r),
164            _ => Err(TryIntoError::TryIntoRequestFailed),
165        }
166    }
167}
168
169impl From<AddDeviceNotificationRequest> for Request {
170    fn from(request: AddDeviceNotificationRequest) -> Self {
171        Request::AddDeviceNotification(request)
172    }
173}
174
175impl TryInto<AddDeviceNotificationRequest> for Request {
176    type Error = TryIntoError;
177
178    fn try_into(self) -> Result<AddDeviceNotificationRequest, Self::Error> {
179        match self {
180            Request::AddDeviceNotification(r) => Ok(r),
181            _ => Err(TryIntoError::TryIntoRequestFailed),
182        }
183    }
184}
185
186impl From<DeleteDeviceNotificationRequest> for Request {
187    fn from(request: DeleteDeviceNotificationRequest) -> Self {
188        Request::DeleteDeviceNotification(request)
189    }
190}
191
192impl TryInto<DeleteDeviceNotificationRequest> for Request {
193    type Error = TryIntoError;
194
195    fn try_into(self) -> Result<DeleteDeviceNotificationRequest, Self::Error> {
196        match self {
197            Request::DeleteDeviceNotification(r) => Ok(r),
198            _ => Err(TryIntoError::TryIntoRequestFailed),
199        }
200    }
201}
202
203impl From<DeviceNotificationRequest> for Request {
204    fn from(request: DeviceNotificationRequest) -> Self {
205        Request::DeviceNotification(request)
206    }
207}
208
209impl TryInto<DeviceNotificationRequest> for Request {
210    type Error = TryIntoError;
211
212    fn try_into(self) -> Result<DeviceNotificationRequest, Self::Error> {
213        match self {
214            Request::DeviceNotification(r) => Ok(r),
215            _ => Err(TryIntoError::TryIntoRequestFailed),
216        }
217    }
218}
219
220impl From<ReadWriteRequest> for Request {
221    fn from(request: ReadWriteRequest) -> Self {
222        Request::ReadWrite(request)
223    }
224}
225
226impl TryInto<ReadWriteRequest> for Request {
227    type Error = TryIntoError;
228
229    fn try_into(self) -> Result<ReadWriteRequest, Self::Error> {
230        match self {
231            Request::ReadWrite(r) => Ok(r),
232            _ => Err(TryIntoError::TryIntoRequestFailed),
233        }
234    }
235}
236
237/// ADS Invalid request
238#[derive(Debug, Clone, PartialEq, Eq)]
239pub struct InvalidRequest {
240    command_id: CommandID,
241}
242
243impl InvalidRequest {
244    pub fn new() -> Self {
245        InvalidRequest {
246            command_id: CommandID::Invalid,
247        }
248    }
249}
250
251impl Default for InvalidRequest {
252    fn default() -> Self {
253        Self::new()
254    }
255}
256
257/// ADS read device info request
258#[derive(Debug, Clone, PartialEq, Eq)]
259pub struct ReadDeviceInfoRequest {
260    command_id: CommandID,
261}
262
263impl ReadDeviceInfoRequest {
264    pub fn new() -> Self {
265        ReadDeviceInfoRequest {
266            command_id: CommandID::ReadDeviceInfo,
267        }
268    }
269}
270
271impl Default for ReadDeviceInfoRequest {
272    fn default() -> Self {
273        Self::new()
274    }
275}
276
277/// ADS read device info request
278#[derive(Debug, Clone, PartialEq, Eq)]
279pub struct ReadStateRequest {
280    command_id: CommandID,
281}
282
283impl ReadStateRequest {
284    pub fn new() -> Self {
285        ReadStateRequest {
286            command_id: CommandID::ReadState,
287        }
288    }
289}
290
291impl Default for ReadStateRequest {
292    fn default() -> Self {
293        Self::new()
294    }
295}
296
297/// ADS read device info request
298#[derive(Debug, Clone, PartialEq, Eq)]
299pub struct DeviceNotificationRequest {
300    command_id: CommandID,
301}
302
303impl DeviceNotificationRequest {
304    pub fn new() -> Self {
305        DeviceNotificationRequest {
306            command_id: CommandID::DeviceNotification,
307        }
308    }
309}
310
311impl Default for DeviceNotificationRequest {
312    fn default() -> Self {
313        Self::new()
314    }
315}
316
317/// ADS Read
318#[derive(Debug, Clone, PartialEq, Eq)]
319pub struct ReadRequest {
320    pub index_group: u32,
321    pub index_offset: u32,
322    pub length: u32,
323    pub command_id: CommandID,
324}
325
326impl ReadRequest {
327    pub fn new(index_group: u32, index_offset: u32, length: u32) -> Self {
328        ReadRequest {
329            index_group,
330            index_offset,
331            length,
332            command_id: CommandID::Read,
333        }
334    }
335}
336
337impl WriteTo for ReadRequest {
338    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
339        wtr.write_u32::<LittleEndian>(self.index_group)?;
340        wtr.write_u32::<LittleEndian>(self.index_offset)?;
341        wtr.write_u32::<LittleEndian>(self.length)?;
342        Ok(())
343    }
344}
345
346impl ReadFrom for ReadRequest {
347    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
348        Ok(ReadRequest {
349            index_group: read.read_u32::<LittleEndian>()?,
350            index_offset: read.read_u32::<LittleEndian>()?,
351            length: read.read_u32::<LittleEndian>()?,
352            command_id: CommandID::Read,
353        })
354    }
355}
356
357///ADS Write
358#[derive(Debug, Clone, PartialEq, Eq)]
359pub struct WriteRequest {
360    pub index_group: u32,
361    pub index_offset: u32,
362    pub length: u32,
363    pub data: Vec<u8>,
364    pub command_id: CommandID,
365}
366
367impl WriteRequest {
368    pub fn new(index_group: u32, index_offset: u32, data: Vec<u8>) -> Self {
369        WriteRequest {
370            index_group,
371            index_offset,
372            length: data.len() as u32,
373            data,
374            command_id: CommandID::Write,
375        }
376    }
377}
378
379impl WriteTo for WriteRequest {
380    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
381        wtr.write_u32::<LittleEndian>(self.index_group)?;
382        wtr.write_u32::<LittleEndian>(self.index_offset)?;
383        wtr.write_u32::<LittleEndian>(self.length)?;
384        wtr.write_all(self.data.as_slice())?;
385        Ok(())
386    }
387}
388
389impl ReadFrom for WriteRequest {
390    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
391        let index_group = read.read_u32::<LittleEndian>()?;
392        let index_offset = read.read_u32::<LittleEndian>()?;
393        let length = read.read_u32::<LittleEndian>()?;
394        let mut data: Vec<u8> = Vec::with_capacity(length as usize);
395        read.read_to_end(&mut data)?;
396
397        Ok(WriteRequest {
398            index_group,
399            index_offset,
400            length,
401            data,
402            command_id: CommandID::Write,
403        })
404    }
405}
406
407/// ADS Write Control
408#[derive(Debug, Clone, PartialEq, Eq)]
409pub struct WriteControlRequest {
410    pub ads_state: AdsState,
411    pub device_state: u16,
412    pub length: u32,
413    pub data: Vec<u8>,
414    pub command_id: CommandID,
415}
416
417impl WriteControlRequest {
418    pub fn new(ads_state: AdsState, device_state: u16, length: u32, data: Vec<u8>) -> Self {
419        WriteControlRequest {
420            ads_state,
421            device_state,
422            length,
423            data,
424            command_id: CommandID::WriteControl,
425        }
426    }
427}
428
429impl WriteTo for WriteControlRequest {
430    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
431        self.ads_state.write_to(&mut wtr)?;
432        wtr.write_u16::<LittleEndian>(self.device_state)?;
433        wtr.write_u32::<LittleEndian>(self.length)?;
434        wtr.write_all(self.data.as_slice())?;
435        Ok(())
436    }
437}
438
439impl ReadFrom for WriteControlRequest {
440    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
441        let ads_state = AdsState::read_from(read)?;
442        let device_state = read.read_u16::<LittleEndian>()?;
443        let length = read.read_u32::<LittleEndian>()?;
444        let mut data: Vec<u8> = Vec::with_capacity(length as usize);
445        read.read_to_end(&mut data)?;
446        Ok(WriteControlRequest {
447            ads_state,
448            device_state,
449            length,
450            data,
451            command_id: CommandID::WriteControl,
452        })
453    }
454}
455
456/// ADS Add Device Notification
457#[derive(Debug, PartialEq, Clone, Eq)]
458pub struct AddDeviceNotificationRequest {
459    pub index_group: u32,
460    pub index_offset: u32,
461    pub length: u32,
462    pub transmission_mode: AdsTransMode,
463    pub max_delay: u32,
464    pub cycle_time: u32,
465    pub reserved: [u8; 16],
466    pub command_id: CommandID,
467}
468
469impl AddDeviceNotificationRequest {
470    pub fn new(
471        index_group: u32,
472        index_offset: u32,
473        length: u32,
474        transmission_mode: AdsTransMode,
475        max_delay: u32,
476        cycle_time: u32,
477    ) -> Self {
478        AddDeviceNotificationRequest {
479            index_group,
480            index_offset,
481            length,
482            transmission_mode,
483            max_delay,
484            cycle_time,
485            reserved: [0; 16],
486            command_id: CommandID::AddDeviceNotification,
487        }
488    }
489}
490
491impl WriteTo for AddDeviceNotificationRequest {
492    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
493        wtr.write_u32::<LittleEndian>(self.index_group)?;
494        wtr.write_u32::<LittleEndian>(self.index_offset)?;
495        wtr.write_u32::<LittleEndian>(self.length)?;
496        self.transmission_mode.write_to(&mut wtr)?;
497        wtr.write_u32::<LittleEndian>(self.max_delay)?;
498        wtr.write_u32::<LittleEndian>(self.cycle_time)?;
499        wtr.write_all(&self.reserved)?;
500        Ok(())
501    }
502}
503
504impl ReadFrom for AddDeviceNotificationRequest {
505    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
506        Ok(AddDeviceNotificationRequest {
507            index_group: read.read_u32::<LittleEndian>()?,
508            index_offset: read.read_u32::<LittleEndian>()?,
509            length: read.read_u32::<LittleEndian>()?,
510            transmission_mode: AdsTransMode::read_from(read)?,
511            max_delay: read.read_u32::<LittleEndian>()?,
512            cycle_time: read.read_u32::<LittleEndian>()?,
513            reserved: [0; 16],
514            command_id: CommandID::AddDeviceNotification,
515        })
516    }
517}
518
519/// ADS read device info request
520#[derive(Debug, Clone, PartialEq, Eq)]
521pub struct DeleteDeviceNotificationRequest {
522    pub handle: u32,
523    pub command_id: CommandID,
524}
525
526impl WriteTo for DeleteDeviceNotificationRequest {
527    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
528        wtr.write_u32::<LittleEndian>(self.handle)?;
529        Ok(())
530    }
531}
532
533impl ReadFrom for DeleteDeviceNotificationRequest {
534    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
535        Ok(DeleteDeviceNotificationRequest {
536            handle: read.read_u32::<LittleEndian>()?,
537            command_id: CommandID::DeleteDeviceNotification,
538        })
539    }
540}
541
542impl DeleteDeviceNotificationRequest {
543    pub fn new(handle: u32) -> Self {
544        DeleteDeviceNotificationRequest {
545            handle,
546            command_id: CommandID::DeleteDeviceNotification,
547        }
548    }
549}
550
551/// ADS Read Write
552#[derive(Debug, Clone, PartialEq, Eq)]
553pub struct ReadWriteRequest {
554    pub index_group: u32,
555    pub index_offset: u32,
556    pub read_length: u32,
557    pub write_length: u32,
558    pub data: Vec<u8>,
559    pub command_id: CommandID,
560}
561
562impl ReadWriteRequest {
563    pub fn new(index_group: u32, index_offset: u32, read_length: u32, data: Vec<u8>) -> Self {
564        ReadWriteRequest {
565            index_group,
566            index_offset,
567            read_length,
568            write_length: data.len() as u32,
569            data,
570            command_id: CommandID::ReadWrite,
571        }
572    }
573}
574
575impl WriteTo for ReadWriteRequest {
576    fn write_to<W: Write>(&self, mut wtr: W) -> io::Result<()> {
577        wtr.write_u32::<LittleEndian>(self.index_group)?;
578        wtr.write_u32::<LittleEndian>(self.index_offset)?;
579        wtr.write_u32::<LittleEndian>(self.read_length)?;
580        wtr.write_u32::<LittleEndian>(self.write_length)?;
581        wtr.write_all(self.data.as_slice())?;
582        Ok(())
583    }
584}
585
586impl ReadFrom for ReadWriteRequest {
587    fn read_from<R: Read>(read: &mut R) -> io::Result<Self> {
588        let index_group = read.read_u32::<LittleEndian>()?;
589        let index_offset = read.read_u32::<LittleEndian>()?;
590        let read_length = read.read_u32::<LittleEndian>()?;
591        let write_length = read.read_u32::<LittleEndian>()?;
592        let mut data: Vec<u8> = vec![0; write_length as usize];
593        read.read_exact(&mut data)?;
594
595        Ok(ReadWriteRequest {
596            index_group,
597            index_offset,
598            read_length,
599            write_length,
600            data,
601            command_id: CommandID::ReadWrite,
602        })
603    }
604}
605
606#[cfg(test)]
607mod tests {
608    use super::*;
609
610    #[test]
611    fn request_from_invalid() {
612        let invalid_request = InvalidRequest::new();
613
614        assert_eq!(
615            Request::Invalid(invalid_request.clone()),
616            Request::from(invalid_request)
617        );
618    }
619
620    #[test]
621    fn request_try_into_invalid() {
622        let invalid_request = InvalidRequest::new();
623
624        let request = Request::Invalid(invalid_request.clone());
625        let test = request.try_into().unwrap();
626
627        assert_eq!(invalid_request, test);
628    }
629
630    #[test]
631    fn request_from_read_device_info() {
632        let read_device_info_request = ReadDeviceInfoRequest::new();
633
634        assert_eq!(
635            Request::ReadDeviceInfo(read_device_info_request.clone()),
636            Request::from(read_device_info_request)
637        );
638    }
639
640    #[test]
641    fn request_try_into_read_device_info() {
642        let read_device_info_request = ReadDeviceInfoRequest::new();
643
644        let request = Request::ReadDeviceInfo(read_device_info_request.clone());
645        let test = request.try_into().unwrap();
646
647        assert_eq!(read_device_info_request, test);
648    }
649
650    #[test]
651    fn request_from_read_state() {
652        let read_state_request = ReadStateRequest::new();
653
654        assert_eq!(
655            Request::ReadState(read_state_request.clone()),
656            Request::from(read_state_request)
657        );
658    }
659
660    #[test]
661    fn request_try_into_read_state() {
662        let read_state_request = ReadStateRequest::new();
663
664        let request = Request::ReadState(read_state_request.clone());
665        let test = request.try_into().unwrap();
666
667        assert_eq!(read_state_request, test);
668    }
669
670    #[test]
671    fn request_from_read() {
672        let read_request = ReadRequest::new(1, 1, 1);
673
674        assert_eq!(
675            Request::Read(read_request.clone()),
676            Request::from(read_request)
677        );
678    }
679
680    #[test]
681    fn request_try_into_read() {
682        let read_request = ReadRequest::new(1, 1, 1);
683
684        let request = Request::Read(read_request.clone());
685        let test = request.try_into().unwrap();
686
687        assert_eq!(read_request, test);
688    }
689
690    #[test]
691    fn request_from_write() {
692        let write_request = WriteRequest::new(1, 1, vec![88]);
693
694        assert_eq!(
695            Request::Write(write_request.clone()),
696            Request::from(write_request)
697        );
698    }
699
700    #[test]
701    fn request_try_into_write() {
702        let write_request = WriteRequest::new(1, 1, vec![88]);
703        let request = Request::Write(write_request.clone());
704        let test = request.try_into().unwrap();
705
706        assert_eq!(write_request, test);
707    }
708
709    #[test]
710    fn request_from_write_control() {
711        let write_control_request =
712            WriteControlRequest::new(AdsState::AdsStateConfig, 1, 1, vec![88]);
713
714        assert_eq!(
715            Request::WriteControl(write_control_request.clone()),
716            Request::from(write_control_request)
717        );
718    }
719
720    #[test]
721    fn request_try_into_write_control() {
722        let write_control_request =
723            WriteControlRequest::new(AdsState::AdsStateConfig, 1, 1, vec![88]);
724        let request = Request::WriteControl(write_control_request.clone());
725        let test = request.try_into().unwrap();
726
727        assert_eq!(write_control_request, test);
728    }
729
730    #[test]
731    fn request_from_add_device_notification() {
732        let add_device_notification_request =
733            AddDeviceNotificationRequest::new(1, 1, 1, AdsTransMode::Cyclic, 1, 1);
734
735        assert_eq!(
736            Request::AddDeviceNotification(add_device_notification_request.clone()),
737            Request::from(add_device_notification_request)
738        );
739    }
740
741    #[test]
742    fn request_try_into_add_device_notification() {
743        let add_device_notification_request =
744            AddDeviceNotificationRequest::new(1, 1, 1, AdsTransMode::Cyclic, 1, 1);
745
746        let request = Request::AddDeviceNotification(add_device_notification_request.clone());
747        let test = request.try_into().unwrap();
748
749        assert_eq!(add_device_notification_request, test);
750    }
751
752    #[test]
753    fn request_from_delete_device_notification() {
754        let delete_device_notification_request = DeleteDeviceNotificationRequest::new(1);
755
756        assert_eq!(
757            Request::DeleteDeviceNotification(delete_device_notification_request.clone()),
758            Request::from(delete_device_notification_request)
759        );
760    }
761
762    #[test]
763    fn request_try_into_delete_device_notification() {
764        let delete_device_notification_request = DeleteDeviceNotificationRequest::new(1);
765
766        let request = Request::DeleteDeviceNotification(delete_device_notification_request.clone());
767        let test = request.try_into().unwrap();
768
769        assert_eq!(delete_device_notification_request, test);
770    }
771
772    #[test]
773    fn request_from_device_notification() {
774        let device_notification_request = DeviceNotificationRequest::new();
775
776        assert_eq!(
777            Request::DeviceNotification(device_notification_request.clone()),
778            Request::from(device_notification_request)
779        );
780    }
781
782    #[test]
783    fn request_try_into_device_notification() {
784        let device_notification_request = DeviceNotificationRequest::new();
785
786        let request = Request::DeviceNotification(device_notification_request.clone());
787        let test = request.try_into().unwrap();
788
789        assert_eq!(device_notification_request, test);
790    }
791
792    #[test]
793    fn request_from_read_write() {
794        let read_write_request = ReadWriteRequest::new(1, 1, 1, vec![85]);
795
796        assert_eq!(
797            Request::ReadWrite(read_write_request.clone()),
798            Request::from(read_write_request)
799        );
800    }
801
802    #[test]
803    fn request_try_into_read_write() {
804        let read_write_request = ReadWriteRequest::new(1, 1, 1, vec![85]);
805
806        let request = Request::ReadWrite(read_write_request.clone());
807        let test = request.try_into().unwrap();
808
809        assert_eq!(read_write_request, test);
810    }
811
812    #[test]
813    fn read_request_test() {
814        let mut buffer: Vec<u8> = Vec::new();
815        Request::Read(ReadRequest::new(259, 259, 4))
816            .write_to(&mut buffer)
817            .unwrap();
818
819        let compare: Vec<u8> = vec![3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0];
820        assert_eq!(compare, buffer);
821    }
822
823    #[test]
824    fn read_request_read_from_test() {
825        let reader: Vec<u8> = vec![3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0];
826        let request = ReadRequest::read_from(&mut reader.as_slice()).unwrap();
827
828        let compare = ReadRequest::new(259, 259, 4);
829        assert_eq!(request.index_group, compare.index_group);
830        assert_eq!(request.index_offset, compare.index_offset);
831        assert_eq!(request.length, compare.length);
832    }
833
834    #[test]
835    fn write_uint_request_test() {
836        let mut buffer: Vec<u8> = Vec::new();
837        let data: u32 = 12000;
838        Request::Write(WriteRequest::new(259, 259, data.to_le_bytes().to_vec()))
839            .write_to(&mut buffer)
840            .unwrap();
841
842        let compare: Vec<u8> = vec![3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0, 224, 46, 0, 0];
843        assert_eq!(compare, buffer);
844    }
845
846    #[test]
847    fn write_float_request_test() {
848        let mut buffer: Vec<u8> = Vec::new();
849        let data: f32 = 12000.33;
850        Request::Write(WriteRequest::new(259, 259, data.to_le_bytes().to_vec()))
851            .write_to(&mut buffer)
852            .unwrap();
853
854        let compare: Vec<u8> = vec![3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0, 82, 129, 59, 70];
855        assert_eq!(compare, buffer);
856    }
857
858    #[test]
859    fn write_request_read_from_test() {
860        let reader: Vec<u8> = vec![4, 1, 0, 0, 4, 1, 0, 0, 4, 0, 0, 0, 225, 46, 0, 0];
861        let request = WriteRequest::read_from(&mut reader.as_slice()).unwrap();
862        let data_value: u32 = 12001;
863        let data = data_value.to_le_bytes();
864        let compare = WriteRequest::new(260, 260, data.to_vec());
865
866        assert_eq!(
867            request.index_group, compare.index_group,
868            "Wrong index group"
869        );
870        assert_eq!(
871            request.index_offset, compare.index_offset,
872            "Wrong index offset"
873        );
874        assert_eq!(request.length, compare.length, "Wrong length");
875        assert_eq!(request.data, data, "Data not as expected");
876    }
877
878    #[test]
879    fn write_control_request_test() {
880        let mut buffer: Vec<u8> = Vec::new();
881        let data: u8 = 0;
882        Request::WriteControl(WriteControlRequest::new(
883            AdsState::AdsStateIdle,
884            296,
885            1,
886            data.to_le_bytes().to_vec(),
887        ))
888        .write_to(&mut buffer)
889        .unwrap();
890
891        let compare: Vec<u8> = vec![1, 0, 40, 1, 1, 0, 0, 0, 0];
892        assert_eq!(compare, buffer);
893    }
894
895    #[test]
896    fn write_contro_request_read_from_test() {
897        let reader: Vec<u8> = vec![1, 0, 40, 1, 1, 0, 0, 0, 0, 0, 0, 0];
898        let request = WriteControlRequest::read_from(&mut reader.as_slice()).unwrap();
899        let data_value: u32 = 0;
900        let data = data_value.to_le_bytes();
901        let compare = WriteControlRequest::new(AdsState::AdsStateIdle, 296, 1, data.to_vec());
902
903        assert_eq!(request.ads_state, compare.ads_state, "Wrong Ads state");
904        assert_eq!(
905            request.device_state, compare.device_state,
906            "Wrong device state"
907        );
908        assert_eq!(request.length, compare.length, "Wrong length");
909        assert_eq!(request.data, data, "Data not as expected"); //4 byte -> data_value is u32
910    }
911
912    #[test]
913    fn read_write_request_test() {
914        let mut buffer: Vec<u8> = Vec::new();
915        let data: u32 = 40000;
916        let data: Vec<u8> = data.to_le_bytes().to_vec();
917        Request::ReadWrite(ReadWriteRequest::new(259, 259, 4, data))
918            .write_to(&mut buffer)
919            .unwrap();
920
921        let compare: Vec<u8> = vec![
922            3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 64, 156, 0, 0,
923        ];
924        assert_eq!(compare, buffer);
925    }
926
927    #[test]
928    fn read_write_request_read_from_test() {
929        let reader: Vec<u8> = vec![3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 0, 0];
930        let request = ReadWriteRequest::read_from(&mut reader.as_slice()).unwrap();
931        let data_value: u16 = 0;
932        let data = data_value.to_le_bytes();
933        let compare = ReadWriteRequest::new(259, 259, 4, data.to_vec());
934
935        assert_eq!(
936            request.index_group, compare.index_group,
937            "Wrong index group"
938        );
939        assert_eq!(
940            request.index_offset, compare.index_offset,
941            "Wrong index offset"
942        );
943        assert_eq!(
944            request.read_length, compare.read_length,
945            "Wrong read length"
946        );
947        assert_eq!(
948            request.write_length, compare.write_length,
949            "Wrong write length"
950        );
951        assert_eq!(request.command_id, compare.command_id, "Wrong command id");
952        assert_eq!(request.data, data, "Data not as expected"); //2 byte -> data_value is u16
953    }
954
955    #[test]
956    fn add_device_notification_request_test() {
957        let mut buffer: Vec<u8> = Vec::new();
958        Request::AddDeviceNotification(AddDeviceNotificationRequest::new(
959            259,
960            259,
961            4,
962            AdsTransMode::Cyclic,
963            1,
964            1,
965        ))
966        .write_to(&mut buffer)
967        .unwrap();
968
969        let compare: Vec<u8> = vec![
970            3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
971            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
972        ];
973        assert_eq!(compare, buffer);
974    }
975
976    #[test]
977    fn add_device_notification_request_read_from_test() {
978        let reader: Vec<u8> = vec![
979            3, 1, 0, 0, 3, 1, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
980            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
981        ];
982        let request = AddDeviceNotificationRequest::read_from(&mut reader.as_slice()).unwrap();
983        let compare = AddDeviceNotificationRequest::new(259, 259, 4, AdsTransMode::Cyclic, 5, 1);
984
985        assert_eq!(
986            request.index_group, compare.index_group,
987            "Wrong index group"
988        );
989        assert_eq!(
990            request.index_offset, compare.index_offset,
991            "Wrong index offset"
992        );
993        assert_eq!(request.length, compare.length, "Wrong length");
994        assert_eq!(
995            request.transmission_mode, compare.transmission_mode,
996            "Wrong transmission mode"
997        );
998        assert_eq!(
999            request.max_delay, compare.max_delay,
1000            "Wrong max delay wrong"
1001        );
1002        assert_eq!(request.cycle_time, compare.cycle_time, "Wrong cycle time");
1003        assert_eq!(
1004            request.reserved, compare.reserved,
1005            "Reserved not as expected"
1006        );
1007    }
1008
1009    #[test]
1010    fn delete_device_notification_request_test() {
1011        let mut buffer: Vec<u8> = Vec::new();
1012        let notification_handle = DeleteDeviceNotificationRequest::new(1234);
1013        Request::DeleteDeviceNotification(notification_handle)
1014            .write_to(&mut buffer)
1015            .unwrap();
1016
1017        let compare: Vec<u8> = vec![210, 4, 0, 0];
1018        assert_eq!(compare, buffer);
1019    }
1020
1021    #[test]
1022    fn delete_device_notification_request_read_from_test() {
1023        let reader: Vec<u8> = vec![210, 4, 0, 0];
1024        let request = DeleteDeviceNotificationRequest::read_from(&mut reader.as_slice()).unwrap();
1025        let compare = DeleteDeviceNotificationRequest::new(1234);
1026
1027        assert_eq!(request.handle, compare.handle, "Wrong handle");
1028        assert_eq!(request.command_id, compare.command_id, "Wrong command id");
1029    }
1030}
ads_proto/proto/request.rs

ads_proto/proto/
request.rs
