accommodate more no_std builds

Cargo.lock

@@ -5674,7 +5674,6 @@ dependencies = [
  "thiserror 1.0.69",
  "ucd-trie",
  "unicode-segmentation",
- "varbincode",
  "vtparse",
  "wezterm-bidi",
  "wezterm-blob-leases",

Makefile

@@ -4,6 +4,7 @@ all: build
 
 test:
 	cargo nextest run
+	cargo nextest run -p wezterm-escape-parser # no_std by default
 
 check:
 	cargo check

color-types/src/lib.rs

@@ -5,6 +5,7 @@ use core::str::FromStr;
 #[cfg(feature = "std")]
 use csscolorparser::Color;
 #[cfg(not(feature = "std"))]
+#[allow(unused)]
 use num_traits::float::Float;
 #[cfg(feature = "use_serde")]
 use serde::{Deserialize, Serialize};

termwiz/Cargo.toml

@@ -58,8 +58,6 @@ docs = ["widgets", "use_serde", "image", "tmux_cc"]
 criterion.workspace = true
 env_logger.workspace = true
 k9.workspace = true
-varbincode.workspace = true
-
 
 [target."cfg(unix)".dependencies]
 signal-hook.workspace = true

termwiz/src/color.rs

@@ -47,39 +47,3 @@ impl From<ColorSpec> for ColorAttribute {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn from_hsl() {
-        let foo = RgbColor::from_rgb_str("hsl:235 100  50").unwrap();
-        assert_eq!(foo.to_rgb_string(), "#0015ff");
-    }
-
-    #[test]
-    fn from_rgb() {
-        assert!(RgbColor::from_rgb_str("").is_none());
-        assert!(RgbColor::from_rgb_str("#xyxyxy").is_none());
-
-        let black = RgbColor::from_rgb_str("#FFF").unwrap();
-        assert_eq!(black.to_tuple_rgb8(), (0xf0, 0xf0, 0xf0));
-
-        let black = RgbColor::from_rgb_str("#000000").unwrap();
-        assert_eq!(black.to_tuple_rgb8(), (0, 0, 0));
-
-        let grey = RgbColor::from_rgb_str("rgb:D6/D6/D6").unwrap();
-        assert_eq!(grey.to_tuple_rgb8(), (0xd6, 0xd6, 0xd6));
-
-        let grey = RgbColor::from_rgb_str("rgb:f0f0/f0f0/f0f0").unwrap();
-        assert_eq!(grey.to_tuple_rgb8(), (0xf0, 0xf0, 0xf0));
-    }
-
-    #[cfg(feature = "use_serde")]
-    #[test]
-    fn roundtrip_rgbcolor() {
-        let data = varbincode::serialize(&RgbColor::from_named("DarkGreen").unwrap()).unwrap();
-        eprintln!("serialized as {:?}", data);
-        let _decoded: RgbColor = varbincode::deserialize(data.as_slice()).unwrap();
-    }
-}

wezterm-dynamic/src/value.rs

@@ -1,5 +1,6 @@
 use crate::array::Array;
 use crate::object::Object;
+#[allow(unused)]
 #[cfg(not(feature = "std"))]
 use ordered_float::FloatCore;
 use ordered_float::OrderedFloat;

wezterm-escape-parser/Cargo.toml

@@ -31,7 +31,7 @@ wezterm-dynamic.workspace = true
 wezterm-input-types = {workspace = true, default-features=false}
 
 [features]
-std = ["vtparse/std", "thiserror/std", "wezterm-input-types/std", "hex/std"]
+std = ["vtparse/std", "thiserror/std", "wezterm-input-types/std", "hex/std", "wezterm-dynamic/std"]
 kitty-shm = ["dep:nix"]
 use_serde = ["dep:serde", "wezterm-color-types/use_serde", "wezterm-blob-leases/serde", "bitflags/serde", "wezterm-input-types/serde"]
 use_image = ["image", "dep:image"]

wezterm-escape-parser/src/color.rs

@@ -254,3 +254,31 @@ impl From<SrgbaTuple> for ColorSpec {
         ColorSpec::TrueColor(col)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn from_hsl() {
+        let foo = RgbColor::from_rgb_str("hsl:235 100  50").unwrap();
+        assert_eq!(foo.to_rgb_string(), "#0015ff");
+    }
+
+    #[test]
+    fn from_rgb() {
+        assert!(RgbColor::from_rgb_str("").is_none());
+        assert!(RgbColor::from_rgb_str("#xyxyxy").is_none());
+
+        let black = RgbColor::from_rgb_str("#FFF").unwrap();
+        assert_eq!(black.to_tuple_rgb8(), (0xf0, 0xf0, 0xf0));
+
+        let black = RgbColor::from_rgb_str("#000000").unwrap();
+        assert_eq!(black.to_tuple_rgb8(), (0, 0, 0));
+
+        let grey = RgbColor::from_rgb_str("rgb:D6/D6/D6").unwrap();
+        assert_eq!(grey.to_tuple_rgb8(), (0xd6, 0xd6, 0xd6));
+
+        let grey = RgbColor::from_rgb_str("rgb:f0f0/f0f0/f0f0").unwrap();
+        assert_eq!(grey.to_tuple_rgb8(), (0xf0, 0xf0, 0xf0));
+    }
+}

wezterm-escape-parser/src/csi.rs

@@ -144,14 +144,14 @@ pub enum CSI {
 #[cfg(all(test, target_pointer_width = "64"))]
 #[test]
 fn csi_size() {
-    assert_eq!(std::mem::size_of::<Sgr>(), 24);
-    assert_eq!(std::mem::size_of::<Cursor>(), 12);
-    assert_eq!(std::mem::size_of::<Edit>(), 8);
-    assert_eq!(std::mem::size_of::<Mode>(), 24);
-    assert_eq!(std::mem::size_of::<MouseReport>(), 8);
-    assert_eq!(std::mem::size_of::<Window>(), 40);
-    assert_eq!(std::mem::size_of::<Keyboard>(), 8);
-    assert_eq!(std::mem::size_of::<CSI>(), 32);
+    assert_eq!(core::mem::size_of::<Sgr>(), 24);
+    assert_eq!(core::mem::size_of::<Cursor>(), 12);
+    assert_eq!(core::mem::size_of::<Edit>(), 8);
+    assert_eq!(core::mem::size_of::<Mode>(), 24);
+    assert_eq!(core::mem::size_of::<MouseReport>(), 8);
+    assert_eq!(core::mem::size_of::<Window>(), 40);
+    assert_eq!(core::mem::size_of::<Keyboard>(), 8);
+    assert_eq!(core::mem::size_of::<CSI>(), 32);
 }
 
 pub use wezterm_input_types::KittyKeyboardFlags;
@@ -1488,11 +1488,11 @@ pub enum Sgr {
 #[cfg(all(test, target_pointer_width = "64"))]
 #[test]
 fn sgr_size() {
-    assert_eq!(std::mem::size_of::<Intensity>(), 1);
-    assert_eq!(std::mem::size_of::<Underline>(), 1);
-    assert_eq!(std::mem::size_of::<ColorSpec>(), 20);
-    assert_eq!(std::mem::size_of::<Blink>(), 1);
-    assert_eq!(std::mem::size_of::<Font>(), 2);
+    assert_eq!(core::mem::size_of::<Intensity>(), 1);
+    assert_eq!(core::mem::size_of::<Underline>(), 1);
+    assert_eq!(core::mem::size_of::<ColorSpec>(), 20);
+    assert_eq!(core::mem::size_of::<Blink>(), 1);
+    assert_eq!(core::mem::size_of::<Font>(), 2);
 }
 
 impl Display for Sgr {
@@ -2977,7 +2977,7 @@ impl<'a> Iterator for CSIParser<'a> {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "std"))]
 mod test {
     use super::*;
     use std::io::Write;
@@ -2991,8 +2991,7 @@ mod test {
             cparams.push(CsiParam::Integer(p));
         }
         let res = CSI::parse(&cparams, false, control).collect();
-        println!("parsed -> {:#?}", res);
-        assert_eq!(encode(&res), expected);
+        assert_eq!(encode(&res), expected, "parsed -> {res:?}");
         res
     }
 

wezterm-escape-parser/src/esc.rs

@@ -171,6 +171,7 @@ impl Display for Esc {
 #[cfg(test)]
 mod test {
     use super::*;
+    use alloc::string::String;
 
     fn encode(osc: &Esc) -> String {
         format!("{}", osc)

wezterm-escape-parser/src/lib.rs

@@ -90,11 +90,11 @@ impl Action {
 #[cfg(all(test, target_pointer_width = "64"))]
 #[test]
 fn action_size() {
-    assert_eq!(std::mem::size_of::<Action>(), 32);
-    assert_eq!(std::mem::size_of::<DeviceControlMode>(), 16);
-    assert_eq!(std::mem::size_of::<ControlCode>(), 1);
-    assert_eq!(std::mem::size_of::<CSI>(), 32);
-    assert_eq!(std::mem::size_of::<Esc>(), 4);
+    assert_eq!(core::mem::size_of::<Action>(), 32);
+    assert_eq!(core::mem::size_of::<DeviceControlMode>(), 16);
+    assert_eq!(core::mem::size_of::<ControlCode>(), 1);
+    assert_eq!(core::mem::size_of::<CSI>(), 32);
+    assert_eq!(core::mem::size_of::<Esc>(), 4);
 }
 
 /// Encode self as an escape sequence.  The escape sequence may potentially

wezterm-escape-parser/src/parser/mod.rs

@@ -346,7 +346,7 @@ impl<'a, F: FnMut(Action)> VTActor for Performer<'a, F> {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "std"))]
 mod test {
     use super::*;
     use crate::color::ColorSpec;
@@ -740,16 +740,14 @@ mod test {
     fn round_trip_parse(s: &str) -> Vec<Action> {
         let mut p = Parser::new();
         let actions = p.parse_as_vec(s.as_bytes());
-        println!("actions: {:?}", actions);
-        assert_eq!(s, encode(&actions));
+        assert_eq!(s, encode(&actions), "actions: {actions:?}");
         actions
     }
 
     fn parse_as(s: &str, expected: &str) -> Vec<Action> {
         let mut p = Parser::new();
         let actions = p.parse_as_vec(s.as_bytes());
-        println!("actions: {:?}", actions);
-        assert_eq!(expected, encode(&actions));
+        assert_eq!(expected, encode(&actions), "actions: {actions:?}");
         actions
     }
 

wezterm-escape-parser/src/parser/sixel.rs

@@ -190,6 +190,7 @@ mod test {
     use super::*;
     use crate::parser::Parser;
     use crate::{Action, Esc, EscCode};
+    use alloc::boxed::Box;
     use k9::assert_equal as assert_eq;
 
     #[test]