Add new test case

tests/tests.rs

···
 #[cfg(test)]
 mod usage_test {
-    use simple_left_right::{Absorb, WriteGuard, Writer};
+    use simple_left_right::{Absorb, ReadGuard, WriteGuard, Writer};
     use std::{cell::Cell, hint, time::Duration};
 
     fn spin_lock<T: Absorb<O>, O>(writer: &mut Writer<T, O>) -> WriteGuard<'_, T, O> {
···
             assert!(value <= *lock.read());
             lock.apply_op(CounterAddOp(1));
             drop(lock);
+        }
+    }
+
+    #[test]
+    // attempt to find similar breakge to: https://github.com/rust-lang/rust/issues/63787
+    // i don't think it's possible, because you can't get a ref to the other value while still passing
+    // a ref through the function boundary. You can only get a ref to the other value when passing Reader,
+    // which already has a raw ptr. So i think i am not affected by this issue.
+    fn break_ref() {
+        #[derive(Clone, Copy)]
+        struct SetToNone;
+        impl Absorb<SetToNone> for Option<Box<i32>> {
+            fn absorb(&mut self, _operation: SetToNone) {
+                *self = None;
+            }
+        }
+
+        let mut writer = Writer::new(Some(Box::new(0)));
+        let mut reader = writer.build_reader().unwrap();
+
+        two_refs(&mut writer.try_lock().unwrap(), reader.lock());
+
+        fn two_refs(
+            writer: &mut WriteGuard<'_, Option<Box<i32>>, SetToNone>,
+            reader: ReadGuard<'_, Option<Box<i32>>>,
+        ) {
+            drop(reader);
+            writer.apply_op(SetToNone);
         }
     }
 }