{

var i = new PyInt(1);

var ni = (PyObject)i.As<object>();

Assert.AreEqual(i.rawPtr, ni.rawPtr);

Assert.IsTrue(PythonReferenceComparer.Instance.Equals(i, ni));

}

[Test]

var clrObject = (CLRObject)ManagedType.GetManagedObject(pyObjectProxy);

Assert.AreSame(pyObject, clrObject.inst);

var proxiedHandle = pyObjectProxy.GetAttr("Handle").As<IntPtr>();

Assert.AreEqual(pyObject.Handle, proxiedHandle);

#pragma warning disable CS0612 // Type or member is obsolete

const string handlePropertyName = nameof(PyObject.Handle);

#pragma warning restore CS0612 // Type or member is obsolete

var proxiedHandle = pyObjectProxy.GetAttr(handlePropertyName).As<IntPtr>();

Assert.AreEqual(pyObject.DangerousGetAddressOrNull(), proxiedHandle);

}

// regression for https://github.com/pythonnet/pythonnet/issues/451

{

Debug.Assert(obj.AsManagedObject(type).GetType() == type);

// We only needs its Python handle

PyRuntime.XIncref(obj);

return obj.Handle;

return new NewReference(obj).DangerousMoveToPointer();

}

}

}

Assert.AreEqual(ptr, e.Handle);

Assert.AreEqual(2, e.ImpactedObjects.Count);

// Fix for this test, don't do this on general environment

#pragma warning disable CS0618 // Type or member is obsolete

Runtime.Runtime.XIncref(e.Reference);

#pragma warning restore CS0618 // Type or member is obsolete

return false;

};

Finalizer.Instance.IncorrectRefCntResolver += handler;

{

PyString s1 = new PyString("test_string");

// s2 steal a reference from s1

PyString s2 = new PyString(StolenReference.DangerousFromPointer(s1.Handle));

return s1.Handle;

IntPtr address = s1.Reference.DangerousGetAddress();

PyString s2 = new (StolenReference.DangerousFromPointer(address));

return address;

}

}

}

{

PyObject sys = Py.Import("sys");

// We can safely ignore the "m" abi flag

var abiflags = sys.GetAttr("abiflags", "".ToPython()).ToString().Replace("m", "");

var abiflags = sys.HasAttr("abiflags") ? sys.GetAttr("abiflags").ToString() : "";

abiflags = abiflags.Replace("m", "");

if (!string.IsNullOrEmpty(abiflags))

{

string typeName = "Python.Runtime.NativeTypeOffset, Python.Runtime";

using var tbObj = tbPtr.MoveToPyObject();

// the type returned from PyErr_NormalizeException should not be the same type since a new

// exception was raised by initializing the exception

Assert.AreNotEqual(type.Handle, typeObj.Handle);

Assert.IsFalse(PythonReferenceComparer.Instance.Equals(type, typeObj));

// the message should now be the string from the throw exception during normalization

Assert.AreEqual("invalid literal for int() with base 10: 'dummy string'", strObj.ToString());

}

Debug.Assert(name == op.As<string>());

SetIntern(name, op);

var field = type.GetField("f" + name, PyIdentifierFieldFlags)!;

field.SetValue(null, op.rawPtr);

field.SetValue(null, op.DangerousGetAddressOrNull());

}

}

private static void SetIntern(string s, PyString op)

{

_string2interns.Add(s, op);

_intern2strings.Add(op.rawPtr, s);

_intern2strings.Add(op.Reference.DangerousGetAddress(), s);

}

}

}

public StackTrace Traceback { get; } = new StackTrace(1);

#endif

protected internal IntPtr rawPtr = IntPtr.Zero;

protected IntPtr rawPtr = IntPtr.Zero;

internal readonly int run = Runtime.GetRun();

internal BorrowedReference obj => new (rawPtr);

rawPtr = IntPtr.Zero;

}

internal IntPtr DangerousGetAddressOrNull() => rawPtr;

internal void CheckRun()

{

if (run != Runtime.GetRun())

return new ReflectedClrType(type.Steal());

}

public override bool Equals(PyObject? other) => other != null && rawPtr == other.rawPtr;

public override bool Equals(PyObject? other) => rawPtr == other?.DangerousGetAddressOrNull();

public override int GetHashCode() => rawPtr.GetHashCode();

}

public static PythonReferenceComparer Instance { get; } = new PythonReferenceComparer();

public bool Equals(PyObject? x, PyObject? y)

{

return x?.rawPtr == y?.rawPtr;

return x?.DangerousGetAddressOrNull() == y?.DangerousGetAddressOrNull();

}

public int GetHashCode(PyObject obj) => obj.rawPtr.GetHashCode();

public int GetHashCode(PyObject obj) => obj.DangerousGetAddressOrNull().GetHashCode();

private PythonReferenceComparer() { }

}