switched tests to match the new reference changes

pythonnet · lostmsu · Dec 14, 2021 · Oct 17, 2021 · Oct 17, 2021 · Oct 17, 2021
commit 6fa2004137d3d81a105a1adde78f4a08922b1893
diff --git a/src/embed_tests/CodecGroups.cs b/src/embed_tests/CodecGroups.cs
@@ -49,12 +49,12 @@ public void Encodes()
             };
 
             var uri = group.TryEncode(new Uri("data:"));
-            var clrObject = (CLRObject)ManagedType.GetManagedObject(uri.Handle);
+            var clrObject = (CLRObject)ManagedType.GetManagedObject(uri);
             Assert.AreSame(encoder1, clrObject.inst);
             Assert.AreNotSame(encoder2, clrObject.inst);
 
             var tuple = group.TryEncode(Tuple.Create(1));
-            clrObject = (CLRObject)ManagedType.GetManagedObject(tuple.Handle);
+            clrObject = (CLRObject)ManagedType.GetManagedObject(tuple);
             Assert.AreSame(encoder0, clrObject.inst);
         }
 

diff --git a/src/embed_tests/Inheritance.cs b/src/embed_tests/Inheritance.cs
@@ -171,7 +171,7 @@ public int XProp
                     {
                         return scope.Eval<int>($"super(this.__class__, this).{nameof(XProp)}");
                     }
-                    catch (PythonException ex) when (ex.Type.Handle == Exceptions.AttributeError)
+                    catch (PythonException ex) when (PythonReferenceComparer.Instance.Equals(ex.Type, Exceptions.AttributeError))
                     {
                         if (this.extras.TryGetValue(nameof(this.XProp), out object value))
                             return (int)value;

diff --git a/src/embed_tests/References.cs b/src/embed_tests/References.cs
@@ -39,15 +39,9 @@ public void MoveToPyObject_SetsNull()
         public void CanBorrowFromNewReference()
         {
             var dict = new PyDict();
-            NewReference reference = Runtime.PyDict_Items(dict.Reference);
-            try
-            {
-                PythonException.ThrowIfIsNotZero(Runtime.PyList_Reverse(reference));
-            }
-            finally
-            {
-                reference.Dispose();
-            }
+            using NewReference reference = Runtime.PyDict_Items(dict.Reference);
+            BorrowedReference borrowed = reference.BorrowOrThrow();
+            PythonException.ThrowIfIsNotZero(Runtime.PyList_Reverse(borrowed));
         }
     }
 }
diff --git a/src/embed_tests/TestCustomMarshal.cs b/src/embed_tests/TestCustomMarshal.cs
@@ -23,11 +23,11 @@ public static void GetManagedStringTwice()
         {
             const string expected = "FooBar";
 
-            IntPtr op = Runtime.Runtime.PyString_FromString(expected);
-            string s1 = Runtime.Runtime.GetManagedString(op);
-            string s2 = Runtime.Runtime.GetManagedString(op);
+            using var op = Runtime.Runtime.PyString_FromString(expected);
+            string s1 = Runtime.Runtime.GetManagedString(op.BorrowOrThrow());
+            string s2 = Runtime.Runtime.GetManagedString(op.Borrow());
 
-            Assert.AreEqual(1, Runtime.Runtime.Refcount(op));
+            Assert.AreEqual(1, Runtime.Runtime.Refcount(op.Borrow()));
             Assert.AreEqual(expected, s1);
             Assert.AreEqual(expected, s2);
         }

diff --git a/src/embed_tests/TestDomainReload.cs b/src/embed_tests/TestDomainReload.cs
@@ -107,7 +107,7 @@ from Python.EmbeddingTest.Domain import MyClass
                         {
                             Debug.Assert(obj.AsManagedObject(type).GetType() == type);
                             // We only needs its Python handle
-                            PyRuntime.XIncref(obj.Handle);
+                            PyRuntime.XIncref(obj);
                             return obj.Handle;
                         }
                     }
@@ -127,16 +127,16 @@ public override ValueType Execute(ValueType arg)
             {
                 // handle refering a clr object created in previous domain,
                 // it should had been deserialized and became callable agian.
-                IntPtr handle = (IntPtr)arg;
+                using var handle = NewReference.DangerousFromPointer((IntPtr)arg);
                 try
                 {
                     using (Py.GIL())
                     {
-                        IntPtr tp = Runtime.Runtime.PyObject_TYPE(handle);
-                        IntPtr tp_clear = Marshal.ReadIntPtr(tp, TypeOffset.tp_clear);
+                        BorrowedReference tp = Runtime.Runtime.PyObject_TYPE(handle.Borrow());
+                        IntPtr tp_clear = Util.ReadIntPtr(tp, TypeOffset.tp_clear);
                         Assert.That(tp_clear, Is.Not.Null);
 
-                        using (PyObject obj = new PyObject(handle))
+                        using (PyObject obj = new PyObject(handle.Steal()))
                         {
                             obj.InvokeMethod("Method");
                             obj.InvokeMethod("StaticMethod");

diff --git a/src/embed_tests/TestFinalizer.cs b/src/embed_tests/TestFinalizer.cs
@@ -212,7 +212,7 @@ public void ValidateRefCount()
                 Assert.AreEqual(ptr, e.Handle);
                 Assert.AreEqual(2, e.ImpactedObjects.Count);
                 // Fix for this test, don't do this on general environment
-                Runtime.Runtime.XIncref(e.Handle);
+                Runtime.Runtime.XIncref(e.Reference);
                 return false;
             };
             Finalizer.Instance.IncorrectRefCntResolver += handler;

diff --git a/src/embed_tests/TestPyInt.cs b/src/embed_tests/TestPyInt.cs
@@ -86,7 +86,6 @@ public void TestCtorSByte()
         public void TestCtorPyObject()
         {
             var i = new PyInt(5);
-            Runtime.Runtime.XIncref(i.Handle);
             var a = new PyInt(i);
             Assert.AreEqual(5, a.ToInt32());
         }

diff --git a/src/embed_tests/TestPyObject.cs b/src/embed_tests/TestPyObject.cs
@@ -98,7 +98,7 @@ public void GetAttrDefault_IgnoresAttributeErrorOnly()
 
     public class PyObjectTestMethods
     {
-        public string RaisesAttributeError => throw new PythonException(new PyType(new BorrowedReference(Exceptions.AttributeError)), value: null, traceback: null);
-        public string RaisesTypeError => throw new PythonException(new PyType(new BorrowedReference(Exceptions.TypeError)), value: null, traceback: null);
+        public string RaisesAttributeError => throw new PythonException(new PyType(Exceptions.AttributeError), value: null, traceback: null);
+        public string RaisesTypeError => throw new PythonException(new PyType(Exceptions.TypeError), value: null, traceback: null);
     }
 }
diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs
@@ -36,29 +36,31 @@ public static void Py_IsInitializedValue()
         public static void RefCountTest()
         {
             Runtime.Runtime.Py_Initialize();
-            IntPtr op = Runtime.Runtime.PyString_FromString("FooBar");
+            using var op = Runtime.Runtime.PyString_FromString("FooBar");
 
             // New object RefCount should be one
-            Assert.AreEqual(1, Runtime.Runtime.Refcount(op));
+            Assert.AreEqual(1, Runtime.Runtime.Refcount(op.BorrowOrThrow()));
 
             // Checking refcount didn't change refcount
-            Assert.AreEqual(1, Runtime.Runtime.Refcount(op));
+            Assert.AreEqual(1, Runtime.Runtime.Refcount(op.Borrow()));
 
-            // New reference doesn't increase refcount
-            IntPtr p = op;
+            // Borrowing a reference doesn't increase refcount
+            BorrowedReference p = op.Borrow();
             Assert.AreEqual(1, Runtime.Runtime.Refcount(p));
 
             // Py_IncRef/Py_DecRef increase and decrease RefCount
-            Runtime.Runtime.Py_IncRef(op);
-            Assert.AreEqual(2, Runtime.Runtime.Refcount(op));
-            Runtime.Runtime.Py_DecRef(op);
-            Assert.AreEqual(1, Runtime.Runtime.Refcount(op));
+            Runtime.Runtime.Py_IncRef(op.Borrow());
+            Assert.AreEqual(2, Runtime.Runtime.Refcount(p));
+            Runtime.Runtime.Py_DecRef(StolenReference.DangerousFromPointer(op.DangerousGetAddress()));
+            Assert.AreEqual(1, Runtime.Runtime.Refcount(p));
 
             // XIncref/XDecref increase and decrease RefCount
-            Runtime.Runtime.XIncref(op);
-            Assert.AreEqual(2, Runtime.Runtime.Refcount(op));
-            Runtime.Runtime.XDecref(op);
-            Assert.AreEqual(1, Runtime.Runtime.Refcount(op));
+            Runtime.Runtime.XIncref(p);
+            Assert.AreEqual(2, Runtime.Runtime.Refcount(p));
+            Runtime.Runtime.XDecref(p);
+            Assert.AreEqual(1, Runtime.Runtime.Refcount(p));
+
+            op.Dispose();
 
             Runtime.Runtime.Py_Finalize();
         }
@@ -71,22 +73,23 @@ public static void PyCheck_Iter_PyObject_IsIterable_Test()
             Runtime.Native.ABI.Initialize(Runtime.Runtime.PyVersion);
 
             // Tests that a python list is an iterable, but not an iterator
-            using (var pyList = NewReference.DangerousFromPointer(Runtime.Runtime.PyList_New(0)))
+            using (var pyListNew = Runtime.Runtime.PyList_New(0))
             {
+                BorrowedReference pyList = pyListNew.BorrowOrThrow();
                 Assert.IsFalse(Runtime.Runtime.PyIter_Check(pyList));
                 Assert.IsTrue(Runtime.Runtime.PyObject_IsIterable(pyList));
 
                 // Tests that a python list iterator is both an iterable and an iterator
                 using var pyListIter = Runtime.Runtime.PyObject_GetIter(pyList);
-                Assert.IsTrue(Runtime.Runtime.PyObject_IsIterable(pyListIter));
-                Assert.IsTrue(Runtime.Runtime.PyIter_Check(pyListIter));
+                Assert.IsTrue(Runtime.Runtime.PyObject_IsIterable(pyListIter.BorrowOrThrow()));
+                Assert.IsTrue(Runtime.Runtime.PyIter_Check(pyListIter.Borrow()));
             }
 
             // Tests that a python float is neither an iterable nor an iterator
-            using (var pyFloat = NewReference.DangerousFromPointer(Runtime.Runtime.PyFloat_FromDouble(2.73)))
+            using (var pyFloat = Runtime.Runtime.PyFloat_FromDouble(2.73))
             {
-                Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(pyFloat));
-                Assert.IsFalse(Runtime.Runtime.PyIter_Check(pyFloat));
+                Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(pyFloat.BorrowOrThrow()));
+                Assert.IsFalse(Runtime.Runtime.PyIter_Check(pyFloat.Borrow()));
             }
 
             Runtime.Runtime.Py_Finalize();
@@ -104,19 +107,17 @@ public static void PyCheck_Iter_PyObject_IsIterable_ThreadingLock_Test()
                 // Create an instance of threading.Lock, which is one of the very few types that does not have the
                 // TypeFlags.HaveIter set in Python 2. This tests a different code path in PyObject_IsIterable and PyIter_Check.
                 using var threading = Runtime.Runtime.PyImport_ImportModule("threading");
-                Exceptions.ErrorCheck(threading);
-                var threadingDict = Runtime.Runtime.PyModule_GetDict(threading);
+                BorrowedReference threadingDict = Runtime.Runtime.PyModule_GetDict(threading.BorrowOrThrow());
                 Exceptions.ErrorCheck(threadingDict);
-                var lockType = Runtime.Runtime.PyDict_GetItemString(threadingDict, "Lock");
+                BorrowedReference lockType = Runtime.Runtime.PyDict_GetItemString(threadingDict, "Lock");
                 if (lockType.IsNull)
                     throw PythonException.ThrowLastAsClrException();
 
-                using var args = NewReference.DangerousFromPointer(Runtime.Runtime.PyTuple_New(0));
-                using var lockInstance = Runtime.Runtime.PyObject_CallObject(lockType, args);
-                Exceptions.ErrorCheck(lockInstance);
+                using var args = Runtime.Runtime.PyTuple_New(0);
+                using var lockInstance = Runtime.Runtime.PyObject_CallObject(lockType, args.Borrow());
 
-                Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(lockInstance));
-                Assert.IsFalse(Runtime.Runtime.PyIter_Check(lockInstance));
+                Assert.IsFalse(Runtime.Runtime.PyObject_IsIterable(lockInstance.BorrowOrThrow()));
+                Assert.IsFalse(Runtime.Runtime.PyIter_Check(lockInstance.Borrow()));
             }
             finally
             {

diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
@@ -181,12 +181,14 @@ internal static void SetArgsAndCause(BorrowedReference ob, Exception e)
         /// Shortcut for (pointer == NULL) -&gt; throw PythonException
         /// </summary>
         /// <param name="pointer">Pointer to a Python object</param>
-        internal static void ErrorCheck(BorrowedReference pointer)
+        internal static BorrowedReference ErrorCheck(BorrowedReference pointer)
         {
             if (pointer.IsNull)
             {
                 throw PythonException.ThrowLastAsClrException();
             }
+
+            return pointer;
         }
 
         internal static void ErrorCheck(IntPtr pointer) => ErrorCheck(new BorrowedReference(pointer));

diff --git a/src/runtime/finalizer.cs b/src/runtime/finalizer.cs
@@ -57,6 +57,7 @@ public IncorrectFinalizeArgs(IntPtr handle, IReadOnlyCollection<IntPtr> imacted)
                 ImpactedObjects = imacted;
             }
             public IntPtr Handle { get; }
+            public BorrowedReference Reference => new(Handle);
             public IReadOnlyCollection<IntPtr> ImpactedObjects { get; }
         }
 

diff --git a/src/runtime/pythonexception.cs b/src/runtime/pythonexception.cs
@@ -424,24 +424,7 @@ internal static void ThrowIfIsNull(in NewReference ob)
             }
         }
         internal static BorrowedReference ThrowIfIsNull(BorrowedReference ob)
-        {
-            if (ob == null)
-            {
-                throw ThrowLastAsClrException();
-            }
-
-            return ob;
-        }
-
-        internal static IntPtr ThrowIfIsNull(IntPtr ob)
-        {
-            if (ob == IntPtr.Zero)
-            {
-                throw ThrowLastAsClrException();
-            }
-
-            return ob;
-        }
+            => Exceptions.ErrorCheck(ob);
 
         internal static void ThrowIfIsNotZero(int value)
         {