Merge pull request #15 from marcelbuesing/arbitrary

Generate inital arbitrary implementation

Author: Pascal Hertleif

Cargo.lock

@@ -60,6 +60,8 @@ fn main() -> Result<()> {
     writeln!(&mut w, "//! - Version: `{:?}`", dbc.version())?;
     writeln!(&mut w)?;
     writeln!(&mut w, "use bitsh::Pack;")?;
+    writeln!(w, r##"#[cfg(feature = "arb")]"##)?;
+    writeln!(&mut w, "use arbitrary::{{Arbitrary, Unstructured}};")?;
     writeln!(&mut w)?;
 
     render_dbc(&mut w, &dbc).context("could not generate Rust code")?;
@@ -261,6 +263,8 @@ fn render_message(mut w: impl Write, msg: &Message, dbc: &DBC) -> Result<()> {
     writeln!(w, "}}")?;
     writeln!(w)?;
 
+    render_arbitrary(&mut w, &msg)?;
+
     let enums_for_this_message = dbc.value_descriptions().iter().filter_map(|x| {
         if let ValueDescription::Signal {
             message_id,
@@ -545,3 +549,63 @@ fn enum_variant_name(x: &str) -> String {
         x.to_camel_case()
     }
 }
+
+fn render_arbitrary(mut w: impl Write, msg: &Message) -> Result<()> {
+    writeln!(w, r##"#[cfg(feature = "arb")]"##)?;
+    writeln!(
+        w,
+        "impl<'a> Arbitrary<'a> for {typ}",
+        typ = type_name(msg.message_name())
+    )?;
+    writeln!(w, "{{")?;
+    {
+        let mut w = PadAdapter::wrap(&mut w);
+        writeln!(
+            w,
+            "fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, arbitrary::Error> {{"
+        )?;
+        {
+            let mut w = PadAdapter::wrap(&mut w);
+            for signal in msg.signals() {
+                writeln!(
+                    w,
+                    "let {field_name} = {arbitrary_value};",
+                    field_name = field_name(signal.name()),
+                    arbitrary_value = signal_to_arbitrary(signal),
+                )?;
+            }
+
+            let args: Vec<String> = msg
+                .signals()
+                .iter()
+                .map(|signal| field_name(signal.name()))
+                .collect();
+
+            writeln!(
+                w,
+                "{typ}::new({args}).map_err(|_| arbitrary::Error::IncorrectFormat)",
+                typ = type_name(msg.message_name()),
+                args = args.join(",")
+            )?;
+        }
+        writeln!(w, "}}")?;
+    }
+    writeln!(w, "}}")?;
+
+    Ok(())
+}
+
+fn signal_to_arbitrary(signal: &Signal) -> String {
+    if signal.signal_size == 1 {
+        "u.int_in_range(0..=1)? == 1".to_string()
+    } else if signal_is_float_in_rust(signal) {
+        // TODO generate arbitrary value for float
+        format!("{}_f32", signal.min())
+    } else {
+        format!(
+            "u.int_in_range({min}..={max})?",
+            min = signal.min(),
+            max = signal.max()
+        )
+    }
+}

src/main.rs

@@ -5,9 +5,11 @@ authors = ["Pascal Hertleif <[email protected]>"]
 edition = "2018"
 
 [dependencies]
+arbitrary = { version = "1.0", optional = true }
 bitsh = { git = "https://github.com/bitbleep/bitsh/" }
 
 [features]
-default = ["debug"]
+default = ["debug", "arb"]
+arb = ["arbitrary"]
 debug = []
 range_checked = []

testing/can-messages/Cargo.toml

@@ -6,6 +6,8 @@
 //!
 //! - Version: `Version("43")`
 
+#[cfg(feature = "arb")]
+use arbitrary::{Arbitrary, Unstructured};
 use bitsh::Pack;
 
 /// All messages
@@ -165,6 +167,15 @@ impl core::convert::TryFrom<&[u8]> for Foo {
     }
 }
 
+#[cfg(feature = "arb")]
+impl<'a> Arbitrary<'a> for Foo {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, arbitrary::Error> {
+        let voltage = 0_f32;
+        let current = -2048_f32;
+        Foo::new(voltage, current).map_err(|_| arbitrary::Error::IncorrectFormat)
+    }
+}
+
 /// Bar
 ///
 /// - ID: 512 (0x200)
@@ -424,6 +435,17 @@ impl core::convert::TryFrom<&[u8]> for Bar {
     }
 }
 
+#[cfg(feature = "arb")]
+impl<'a> Arbitrary<'a> for Bar {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, arbitrary::Error> {
+        let one = u.int_in_range(0..=3)?;
+        let two = 0_f32;
+        let three = u.int_in_range(0..=7)?;
+        let four = u.int_in_range(0..=3)?;
+        let xtype = u.int_in_range(0..=1)? == 1;
+        Bar::new(one, two, three, four, xtype).map_err(|_| arbitrary::Error::IncorrectFormat)
+    }
+}
 /// Defined values for Three
 #[derive(Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "debug", derive(Debug))]