Mercurial > public > mercurial-scm > hg

diff rust/pyo3-sharedref/tests/test_sharedref.rs @ 52609:d1e304025b90

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rust-pyo3-sharedref: replaced borrow/borrow_mut with RwLock namings The "borrow" word had way too many uses in this context. Originally, it came from the rust-cpython version, which is based on `RefCell`. Before this change, we had untracktable stacks of borrows (first the `Bound`, then the `PySharedRefCell`). In any case, the change to `RwLock` is far from being neutral, and we may need in a future without GIL to also expose blocking methods, to account for in-Rust possible concurrency. Using `read()` and `write()` right now matches our PyO3 habits anyway, where all non-Sync objects have to be wrapped in a RwLock.
author Georges Racinet <georges.racinet@cloudcrane.io>
date Sun, 15 Dec 2024 13:58:31 +0100
parents d85514a88706
children c25d345f5aa5
line wrap: on
line diff
--- a/rust/pyo3-sharedref/tests/test_sharedref.rs	Sun Dec 15 14:42:53 2024 +0100
+++ b/rust/pyo3-sharedref/tests/test_sharedref.rs	Sun Dec 15 13:58:31 2024 +0100
@@ -53,7 +53,7 @@
 ) -> () {
     let cell = &owner.borrow_mut().string;
     let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-    f(&mut shared_ref.borrow_mut());
+    f(&mut shared_ref.write());
 }
 
 #[test]
@@ -119,65 +119,65 @@
 ///
 /// Simply returning the `Result` is not possible, because that is
 /// returning a reference to data owned by the function
-fn assert_try_borrow_string_mut_ok(owner: &Bound<'_, Owner>) {
+fn assert_try_write_string_ok(owner: &Bound<'_, Owner>) {
     let cell = &owner.borrow().string;
     let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-    assert!(shared_ref.try_borrow_mut().is_ok());
+    assert!(shared_ref.try_write().is_ok());
 }
 
-fn assert_try_borrow_string_mut_err(owner: &Bound<'_, Owner>) {
+fn assert_try_write_string_err(owner: &Bound<'_, Owner>) {
     let cell = &owner.borrow().string;
     let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-    assert!(shared_ref.try_borrow_mut().is_err());
+    assert!(shared_ref.try_write().is_err());
 }
 
-fn assert_try_borrow_string_err(owner: &Bound<'_, Owner>) {
+fn assert_try_read_string_err(owner: &Bound<'_, Owner>) {
     let cell = &owner.borrow().string;
     let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-    assert!(shared_ref.try_borrow().is_err());
+    assert!(shared_ref.try_read().is_err());
 }
 
 #[test]
-fn test_try_borrow_mut_while_leaked_ref() -> PyResult<()> {
+fn test_try_write_while_leaked_ref() -> PyResult<()> {
     with_setup(|py, owner| {
-        assert_try_borrow_string_mut_ok(owner);
+        assert_try_write_string_ok(owner);
         let leaked = leak_string(owner);
         {
             let _leaked_ref = unsafe { leaked.try_borrow(py) }.unwrap();
-            assert_try_borrow_string_mut_err(owner);
+            assert_try_write_string_err(owner);
             {
                 let _leaked_ref2 = unsafe { leaked.try_borrow(py) }.unwrap();
-                assert_try_borrow_string_mut_err(owner);
+                assert_try_write_string_err(owner);
             }
-            assert_try_borrow_string_mut_err(owner);
+            assert_try_write_string_err(owner);
         }
-        assert_try_borrow_string_mut_ok(owner);
+        assert_try_write_string_ok(owner);
         Ok(())
     })
 }
 
 #[test]
-fn test_try_borrow_mut_while_leaked_ref_mut() -> PyResult<()> {
+fn test_try_write_while_leaked_ref_mut() -> PyResult<()> {
     with_setup(|py, owner| {
-        assert_try_borrow_string_mut_ok(owner);
+        assert_try_write_string_ok(owner);
         let leaked = leak_string(owner);
         let mut leaked_iter = unsafe { leaked.map(py, |s| s.chars()) };
         {
             let _leaked_ref =
                 unsafe { leaked_iter.try_borrow_mut(py) }.unwrap();
-            assert_try_borrow_string_mut_err(owner);
+            assert_try_write_string_err(owner);
         }
-        assert_try_borrow_string_mut_ok(owner);
+        assert_try_write_string_ok(owner);
         Ok(())
     })
 }
 
 #[test]
-fn test_try_leak_while_borrow_mut() -> PyResult<()> {
+fn test_try_leak_while_write() -> PyResult<()> {
     with_setup(|_py, owner| {
         let cell = &owner.borrow().string;
         let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-        let _mut_ref = shared_ref.borrow_mut();
+        let _mut_ref = shared_ref.write();
 
         assert!(try_leak_string(owner).is_err());
         Ok(())
@@ -186,11 +186,11 @@
 
 #[test]
 #[should_panic(expected = "already mutably borrowed")]
-fn test_leak_while_borrow_mut() {
+fn test_leak_while_write() {
     with_setup(|_py, owner| {
         let cell = &owner.borrow().string;
         let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-        let _mut_ref = shared_ref.borrow_mut();
+        let _mut_ref = shared_ref.write();
 
         leak_string(owner);
         Ok(())
@@ -199,54 +199,54 @@
 }
 
 #[test]
-fn test_try_borrow_mut_while_borrow() -> PyResult<()> {
+fn test_try_write_while_borrow() -> PyResult<()> {
     with_setup(|_py, owner| {
         let cell = &owner.borrow().string;
         let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-        let _ref = shared_ref.borrow();
+        let _ref = shared_ref.read();
 
-        assert_try_borrow_string_mut_err(owner);
+        assert_try_write_string_err(owner);
         Ok(())
     })
 }
 
 #[test]
 #[should_panic(expected = "already borrowed")]
-fn test_borrow_mut_while_borrow() {
+fn test_write_while_borrow() {
     with_setup(|_py, owner| {
         let cell = &owner.borrow().string;
         let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-        let _ref = shared_ref.borrow();
+        let _ref = shared_ref.read();
 
         let shared_ref2 = unsafe { cell.borrow_with_owner(owner) };
-        let _mut_ref = shared_ref2.borrow_mut();
+        let _mut_ref = shared_ref2.write();
         Ok(())
     })
     .expect("should already have panicked")
 }
 
 #[test]
-fn test_try_borrow_while_borrow_mut() -> PyResult<()> {
+fn test_try_borrow_while_write() -> PyResult<()> {
     with_setup(|_py, owner| {
         let cell = &owner.borrow().string;
         let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-        let _mut_ref = shared_ref.borrow_mut();
+        let _mut_ref = shared_ref.write();
 
-        assert_try_borrow_string_err(owner);
+        assert_try_read_string_err(owner);
         Ok(())
     })
 }
 
 #[test]
 #[should_panic(expected = "already mutably borrowed")]
-fn test_borrow_while_borrow_mut() {
+fn test_borrow_while_write() {
     with_setup(|_py, owner| {
         let cell = &owner.borrow().string;
         let shared_ref = unsafe { cell.borrow_with_owner(owner) };
-        let _mut_ref = shared_ref.borrow_mut();
+        let _mut_ref = shared_ref.write();
 
         let shared_ref2 = unsafe { cell.borrow_with_owner(owner) };
-        let _ref = shared_ref2.borrow();
+        let _ref = shared_ref2.read();
         Ok(())
     })
     .expect("should already have panicked")