diff --git a/implementations/rust/oo/src/text/mod.rs b/implementations/rust/oo/src/text/mod.rs
index 91304bd..23f922b 100644
--- a/implementations/rust/oo/src/text/mod.rs
+++ b/implementations/rust/oo/src/text/mod.rs
@@ -82,83 +82,79 @@ mod unusual_float_tests {
     use std::io;
     use crate::*;
 
-    fn d32(v: f32) {
-        println!("{}{}{}{}{:?}: preserves {:?}",
-                 if v.is_nan() { "nan " } else { "" },
-                 if v.is_infinite() { "inf " } else { "" },
-                 if v.is_subnormal() { "sub " } else { "" },
-                 if v.is_sign_positive() { "+ve " } else { "-ve " },
-                 v,
-                 iovalue(v));
+    fn d32(u: u32, expected: &str) {
+        let v = f32::from_bits(u);
+        let w = iovalue(v);
+        assert_eq!(format!("{:?}", w), expected);
+        let x = expected.parse::<IOValue>().unwrap();
+        assert_eq!(x, w);
     }
 
-    fn d64(v: f64) {
-        println!("{}{}{}{}{:?}: preserves {:?}",
-                 if v.is_nan() { "nan " } else { "" },
-                 if v.is_infinite() { "inf " } else { "" },
-                 if v.is_subnormal() { "sub " } else { "" },
-                 if v.is_sign_positive() { "+ve " } else { "-ve " },
-                 v,
-                 iovalue(v));
+    fn d64(u: u64, expected: &str) {
+        let v = f64::from_bits(u);
+        let w = iovalue(v);
+        assert_eq!(format!("{:?}", w), expected);
+        let x = expected.parse::<IOValue>().unwrap();
+        assert_eq!(x, w);
     }
 
     #[test] fn subnormal32() -> io::Result<()> {
-        d32(f32::from_bits(0x00000100));
-        d32(f32::from_bits(0x80000100));
+        d32(0x00000100, "3.59e-43f");
+        d32(0x80000100, "-3.59e-43f");
         Ok(())
     }
 
     #[test] fn normal32() -> io::Result<()> {
-        d32(f32::from_bits(0x01000000));
-        d32(f32::from_bits(0x81000000));
+        d32(0x01000000, "2.3509887e-38f");
+        d32(0x81000000, "-2.3509887e-38f");
         Ok(())
     }
 
     #[test] fn nan32() -> io::Result<()> {
-        d32(f32::from_bits(0x7fc00000));
-        d32(f32::from_bits(0x7fc5a5a5));
-        d32(f32::from_bits(0x7f800001));
-        d32(f32::from_bits(0x7f85a5a5));
-        d32(f32::from_bits(0xffc00000));
-        d32(f32::from_bits(0xffc5a5a5));
-        d32(f32::from_bits(0xff800001));
-        d32(f32::from_bits(0xff85a5a5));
+        d32(0x7fc00000, "#xf\"7fc00000\"");
+        d32(0x7fc5a5a5, "#xf\"7fc5a5a5\"");
+        d32(0x7f800001, "#xf\"7f800001\"");
+        d32(0x7f85a5a5, "#xf\"7f85a5a5\"");
+        d32(0xffc00000, "#xf\"ffc00000\"");
+        d32(0xffc5a5a5, "#xf\"ffc5a5a5\"");
+        d32(0xff800001, "#xf\"ff800001\"");
+        d32(0xff85a5a5, "#xf\"ff85a5a5\"");
         Ok(())
     }
 
     #[test] fn inf32() -> io::Result<()> {
-        d32(f32::from_bits(0x7f800000));
-        d32(f32::from_bits(0xff800000));
+        d32(0x7f800000, "#xf\"7f800000\"");
+        d32(0xff800000, "#xf\"ff800000\"");
         Ok(())
     }
 
     #[test] fn subnormal64() -> io::Result<()> {
-        d64(f64::from_bits(0x0000000000000100));
-        d64(f64::from_bits(0x8000000000000100));
+        d64(0x0000000000000100, "1.265e-321");
+        d64(0x8000000000000100, "-1.265e-321");
         Ok(())
     }
 
     #[test] fn normal64() -> io::Result<()> {
-        d64(f64::from_bits(0x0100000000000000));
-        d64(f64::from_bits(0x8100000000000000));
+        d64(0x0100000000000000, "7.291122019556398e-304");
+        d64(0x8100000000000000, "-7.291122019556398e-304");
         Ok(())
     }
 
     #[test] fn nan64() -> io::Result<()> {
-        d64(f64::from_bits(0x7ff8000000000000));
-        d64(f64::from_bits(0x7ff85a5a5a5a5a5a));
-        d64(f64::from_bits(0x7ff0000000000001));
-        d64(f64::from_bits(0x7ff05a5a5a5a5a5a));
-        d64(f64::from_bits(0xfff8000000000000));
-        d64(f64::from_bits(0xfff85a5a5a5a5a5a));
-        d64(f64::from_bits(0xfff0000000000001));
-        d64(f64::from_bits(0xfff05a5a5a5a5a5a));
+        d64(0x7ff8000000000000, "#xd\"7ff8000000000000\"");
+        d64(0x7ff85a5a5a5a5a5a, "#xd\"7ff85a5a5a5a5a5a\"");
+        d64(0x7ff0000000000001, "#xd\"7ff0000000000001\"");
+        d64(0x7ff05a5a5a5a5a5a, "#xd\"7ff05a5a5a5a5a5a\"");
+        d64(0xfff8000000000000, "#xd\"fff8000000000000\"");
+        d64(0xfff85a5a5a5a5a5a, "#xd\"fff85a5a5a5a5a5a\"");
+        d64(0xfff0000000000001, "#xd\"fff0000000000001\"");
+        d64(0xfff05a5a5a5a5a5a, "#xd\"fff05a5a5a5a5a5a\"");
         Ok(())
     }
 
     #[test] fn inf64() -> io::Result<()> {
-        d64(f64::from_bits(0x7ff0000000000000));
-        d64(f64::from_bits(0xfff0000000000000));
+        d64(0x7ff0000000000000, "#xd\"7ff0000000000000\"");
+        d64(0xfff0000000000000, "#xd\"fff0000000000000\"");
         Ok(())
     }
 }