improve irctl encode compare tests

Signed-off-by: Sean Young <[email protected]>

Author: seanyoung

Diff for: TODO

@@ -13,6 +13,9 @@
 - cir decode irp should read IrpProtocols.xml
 - cir decode keymap should support keymap.toml
 - access to io_error in aya
+- parse of keymap.toml should ensure that raw codes have trailing spaces
+  -> remove Message.extend() hack
+- cir transmit rawir -S sony15:12 -r 2 ??
 
 irp language oddities
 

Diff for: src/keymap/protocol.rs

@@ -217,180 +217,14 @@ const LINUX_PROTOCOLS: &[LinuxProtocol] = &[
     }
 ];
 
-#[cfg(test)]
-mod test {
-    use super::LinuxProtocol;
-    use irp::{Irp, Vartable};
-    use rand::RngCore;
-    use std::ffi::CStr;
+#[test]
+fn find_like() {
+    let p = LinuxProtocol::find_like("rc6-mce").unwrap();
+    assert_eq!(p.name, "rc6_mce");
 
-    #[test]
-    fn compare_encode_to_irctl() {
-        for proto in [
-            libirctl::rc_proto::RC_PROTO_RC5,
-            libirctl::rc_proto::RC_PROTO_RC5X_20,
-            libirctl::rc_proto::RC_PROTO_RC5_SZ,
-            libirctl::rc_proto::RC_PROTO_JVC,
-            libirctl::rc_proto::RC_PROTO_SONY12,
-            libirctl::rc_proto::RC_PROTO_SONY15,
-            libirctl::rc_proto::RC_PROTO_SONY20,
-            libirctl::rc_proto::RC_PROTO_NEC,
-            libirctl::rc_proto::RC_PROTO_NECX,
-            libirctl::rc_proto::RC_PROTO_NEC32,
-            libirctl::rc_proto::RC_PROTO_SANYO,
-            libirctl::rc_proto::RC_PROTO_RC6_0,
-            libirctl::rc_proto::RC_PROTO_RC6_6A_20,
-            libirctl::rc_proto::RC_PROTO_RC6_6A_24,
-            libirctl::rc_proto::RC_PROTO_RC6_6A_32,
-            libirctl::rc_proto::RC_PROTO_RC6_MCE,
-            libirctl::rc_proto::RC_PROTO_SHARP,
-            libirctl::rc_proto::RC_PROTO_RCMM12,
-            libirctl::rc_proto::RC_PROTO_RCMM24,
-            libirctl::rc_proto::RC_PROTO_RCMM32,
-            libirctl::rc_proto::RC_PROTO_XBOX_DVD,
-        ] {
-            let name = unsafe { CStr::from_ptr(libirctl::protocol_name(proto)) }
-                .to_str()
-                .unwrap();
-            let linux = LinuxProtocol::find(name).unwrap();
+    let p = LinuxProtocol::find_like("rcmm12").unwrap();
+    assert_eq!(p.name, "rc-mm-12");
 
-            assert_eq!(linux.scancode_mask, unsafe {
-                libirctl::protocol_scancode_mask(proto)
-            });
-            assert_eq!(linux.protocol_no, proto as u32);
-            let mut rng = rand::thread_rng();
-
-            if unsafe { libirctl::protocol_encoder_available(proto) } {
-                let irp = Irp::parse(linux.irp.unwrap()).unwrap();
-
-                if proto == libirctl::rc_proto::RC_PROTO_NEC
-                    || proto == libirctl::rc_proto::RC_PROTO_NECX
-                    || proto == libirctl::rc_proto::RC_PROTO_NEC32
-                {
-                    assert_eq!(irp.carrier(), 38400);
-                } else if proto == libirctl::rc_proto::RC_PROTO_JVC {
-                    assert_eq!(irp.carrier(), 37900);
-                } else {
-                    assert_eq!(irp.carrier(), unsafe {
-                        libirctl::protocol_carrier(proto) as i64
-                    });
-                }
-
-                let max_size = unsafe { libirctl::protocol_max_size(proto) } as usize;
-
-                let mut irctl = vec![0u32; max_size];
-
-                for _ in 0..1000 {
-                    let scancode = rng.next_u32() & linux.scancode_mask;
-
-                    irctl.resize(max_size as usize, 0);
-
-                    let len =
-                        unsafe { libirctl::protocol_encode(proto, scancode, irctl.as_mut_ptr()) };
-
-                    assert!(
-                        len as usize <= max_size,
-                        "{len} {max_size} proto:{proto:?} scancode:{scancode:#x}"
-                    );
-
-                    irctl.resize(len as usize, 0);
-
-                    let mut vars = Vartable::new();
-
-                    vars.set("CODE".into(), scancode as i64);
-
-                    let mut our = irp.encode_raw(vars, 0).unwrap();
-                    our.remove_trailing_gap();
-
-                    if [
-                        libirctl::rc_proto::RC_PROTO_JVC,
-                        libirctl::rc_proto::RC_PROTO_NEC,
-                        libirctl::rc_proto::RC_PROTO_NECX,
-                        libirctl::rc_proto::RC_PROTO_NEC32,
-                        libirctl::rc_proto::RC_PROTO_SANYO,
-                        libirctl::rc_proto::RC_PROTO_SHARP,
-                        libirctl::rc_proto::RC_PROTO_RC6_0,
-                        libirctl::rc_proto::RC_PROTO_RC6_6A_20,
-                        libirctl::rc_proto::RC_PROTO_RC6_6A_24,
-                        libirctl::rc_proto::RC_PROTO_RC6_6A_32,
-                        libirctl::rc_proto::RC_PROTO_RC6_MCE,
-                    ]
-                    .contains(&proto)
-                    {
-                        assert!(compare_with_rounding(&irctl, &our.raw));
-                    } else {
-                        assert_eq!(irctl, our.raw);
-                    }
-                }
-            } else if let Some(irp) = linux.irp {
-                let irp = Irp::parse(irp).unwrap();
-
-                for _ in 0..1000 {
-                    let scancode = rng.next_u32() & linux.scancode_mask;
-
-                    let mut vars = Vartable::new();
-
-                    vars.set("CODE".into(), scancode as i64);
-
-                    let our = irp.encode_raw(vars, 0).unwrap();
-
-                    assert!(!our.raw.is_empty());
-                }
-            }
-        }
-    }
-
-    fn compare_with_rounding(l: &[u32], r: &[u32]) -> bool {
-        if l == r {
-            return true;
-        }
-
-        if l.len() != r.len() {
-            println!(
-                "comparing:\n{:?} with\n{:?}\n have different lengths {} and {}",
-                l,
-                r,
-                l.len(),
-                r.len()
-            );
-
-            return false;
-        }
-
-        for i in 0..l.len() {
-            // sharp gap in the middle
-            if l[i] == 40000 && r[i] == 43560 {
-                continue;
-            }
-
-            let diff = l[i].abs_diff(r[i]);
-
-            // is the difference more than 168
-            if diff > 168 {
-                println!(
-                    "comparing:\nleft:{:?} with\nright:{:?}\nfailed at position {} out of {} diff {diff}",
-                    l,
-                    r,
-                    i,
-                    l.len()
-                );
-
-                return false;
-            }
-        }
-
-        true
-    }
-
-    #[test]
-    fn find_like() {
-        let p = LinuxProtocol::find_like("rc6-mce").unwrap();
-        assert_eq!(p.name, "rc6_mce");
-
-        let p = LinuxProtocol::find_like("rcmm12").unwrap();
-        assert_eq!(p.name, "rc-mm-12");
-
-        let p = LinuxProtocol::find_like("sony-12").unwrap();
-        assert_eq!(p.name, "sony12");
-    }
+    let p = LinuxProtocol::find_like("sony-12").unwrap();
+    assert_eq!(p.name, "sony12");
 }