public void TestAsLongGood()
{
var i = new PyLong(5);
var a = PyLong.AsLong(i);
Assert.AreEqual(5, a.ToInt32());
}
public void TestCtorPyObject()
{
var i = new PyLong(5);
Runtime.Runtime.XIncref(i.Handle);
var a = new PyLong(i);
Assert.AreEqual(5, a.ToInt32());
}
public void TestConvertToInt64()
{
var a = new PyLong(5);
Assert.IsInstanceOf(typeof(long), a.ToInt64());
Assert.AreEqual(5, a.ToInt64());
}
public bool TryDecode <T>(PyObject pyObj, out T value)
{
value = default;
if (!typeof(T).IsEnum)
{
return(false);
}
Type etype = Enum.GetUnderlyingType(typeof(T));
if (!PyLong.IsLongType(pyObj))
{
return(false);
}
object result;
try
{
result = pyObj.AsManagedObject(etype);
}
catch (InvalidCastException)
{
return(false);
}
if (Enum.IsDefined(typeof(T), result) || typeof(T).IsFlagsEnum())
{
value = (T)Enum.ToObject(typeof(T), result);
return(true);
}
return(false);
}
public void TestCtorString()
{
const string i = "5";
var a = new PyLong(i);
Assert.AreEqual(5, a.ToInt32());
}
public void TestCtorULong()
{
const ulong i = 5;
var a = new PyLong(i);
Assert.AreEqual(i, a.ToInt32());
}
public void TestCtorDouble()
{
double i = 5.0;
var a = new PyLong(i);
Assert.AreEqual(i, a.ToInt32());
}
public void TestCtorUShort()
{
const ushort i = 5;
var a = new PyLong(i);
Assert.AreEqual(i, a.ToInt32());
}
public void TestCtorSByte()
{
const sbyte i = 5;
var a = new PyLong(i);
Assert.AreEqual(i, a.ToInt32());
}
public static object ToCLI(this PyObject o)
{
if (PySequence.IsSequenceType(o))
{
var list = new List <object>();
foreach (PyObject subo in o)
{
list.Add(subo.ToCLI());
}
return(list);
}
if (PyString.IsStringType(o))
{
return(o.As <string>());
}
if (PyInt.IsIntType(o))
{
return(o.As <long>());
}
if (PyLong.IsLongType(o))
{
return(o.As <long>());
}
if (PyFloat.IsFloatType(o))
{
return(o.As <double>());
}
return(o);
}
public void TestCtorPyObject()
{
var i = new PyLong(5);
var a = new PyLong(i);
Assert.AreEqual(5, a.ToInt32());
}
public void TestCtorPtr()
{
var i = new PyLong(5);
var a = new PyLong(i.Handle);
Assert.AreEqual(5, a.ToInt32());
}
public void TestToInt64()
{
long largeNumber = 8L * 1024L * 1024L * 1024L; // 8 GB
var pyLargeNumber = new PyLong(largeNumber);
Assert.AreEqual(largeNumber, pyLargeNumber.ToInt64());
}
private static void MakeAGarbage(out WeakReference shortWeak, out WeakReference longWeak)
{
PyLong obj = new PyLong(1024);
shortWeak = new WeakReference(obj);
longWeak = new WeakReference(obj, true);
obj = null;
}
private static IntPtr MakeAGarbage(out WeakReference shortWeak, out WeakReference longWeak)
{
PyLong obj = new PyLong(1024);
shortWeak = new WeakReference(obj);
longWeak = new WeakReference(obj, true);
return(obj.Handle);
}
public void TestAsLongBad()
{
var s = new PyString("Foo");
PyLong a = null;
var ex = Assert.Throws<PythonException>(() => a = PyLong.AsLong(s));
StringAssert.StartsWith("invalid literal", ex.Message);
Assert.IsNull(a);
}
public void TestCtorBadPyObject()
{
var i = new PyString("Foo");
PyLong a = null;
var ex = Assert.Throws <ArgumentException>(() => a = new PyLong(i));
StringAssert.StartsWith("object is not a long", ex.Message);
Assert.IsNull(a);
}
public void TestCtorBadString()
{
const string i = "Foo";
PyLong a = null;
var ex = Assert.Throws <PythonException>(() => a = new PyLong(i));
StringAssert.StartsWith("ValueError : invalid literal", ex.Message);
Assert.IsNull(a);
}
public static long GetLong(dynamic dynLongPyObj, ref long?longMember)
{
if (longMember != null)
{
return((long)longMember);
}
using (Py.GIL())
{
var longPy = new PyLong(dynLongPyObj);
longMember = longPy.ToInt64();
return((long)longMember);
}
}
public bool TryDecode <T>(PyObject pyObj, out T value)
{
if (!PyLong.IsLongType(pyObj))
{
value = default;
return(false);
}
using (var pyLong = PyLong.AsLong(pyObj))
{
value = (T)(object)pyLong.ToBigInteger();
return(true);
}
}
public static BigInteger GetBigInteger(dynamic dynLongPyObj, ref BigInteger?bigInt)
{
if (bigInt != null)
{
return((BigInteger)bigInt);
}
using (Py.GIL())
{
var pyLong = new PyLong(dynLongPyObj);
// This is inefficient, and should be reworked in the future
var str = pyLong.ToString();
bigInt = BigInteger.Parse(str);
return((BigInteger)bigInt);
}
}
public object this[object key]
{
get
{
var keyStr = key as string;
if (keyStr != null)
{
if (_dictStrToNumber.ContainsKey(keyStr))
{
return(_dictStrToNumber[keyStr]);
}
BigInteger valHash;
using (Py.GIL())
{
var dynPyNumber = _pyStringStore.__getitem__(key);
var pyNumber = new PyLong(dynPyNumber);
valHash = BigInteger.Parse(pyNumber.ToString());
_dictStrToNumber.Add(keyStr, valHash);
}
return(valHash);
}
var keyHash = key.AsBigInteger();
if (_dictNumberToStr.ContainsKey(keyHash))
{
return(_dictNumberToStr[keyHash]);
}
var valStr = string.Empty;
using (Py.GIL())
{
var dynPyStr = _pyStringStore.__getitem__(key);
var pyString = new PyString(dynPyStr);
valStr = pyString.ToString();
_dictNumberToStr.Add(keyHash, valStr);
}
return(valStr);
}
}
public void ConvertOverflow()
{
using (var num = new PyLong(ulong.MaxValue))
{
IntPtr largeNum = PyRuntime.PyNumber_Add(num.Handle, num.Handle);
try
{
object value;
foreach (var type in _numTypes)
{
bool res = Converter.ToManaged(largeNum, type, out value, true);
Assert.IsFalse(res);
Assert.IsTrue(Exceptions.ExceptionMatches(Exceptions.OverflowError));
Exceptions.Clear();
}
}
finally
{
Exceptions.Clear();
PyRuntime.XDecref(largeNum);
}
}
}
private static IntPtr MakeAGarbage(out WeakReference shortWeak, out WeakReference longWeak)
{
IntPtr handle = IntPtr.Zero;
WeakReference @short = null, @long = null;
// must create Python object in the thread where we have GIL
IntPtr val = PyLong.FromLong(1024);
// must create temp object in a different thread to ensure it is not present
// when conservatively scanning stack for GC roots.
// see https://xamarin.github.io/bugzilla-archives/17/17593/bug.html
var garbageGen = new Thread(() =>
{
var obj = new PyObject(val, skipCollect: true);
@short = new WeakReference(obj);
@long = new WeakReference(obj, true);
handle = obj.Handle;
});
garbageGen.Start();
Assert.IsTrue(garbageGen.Join(TimeSpan.FromSeconds(5)), "Garbage creation timed out");
shortWeak = @short;
longWeak = @long;
return(handle);
}
public void TestIsIntTypeTrue()
{
var i = new PyLong(5);
Assert.True(PyLong.IsLongType(i));
}
public void TestIsLongTypeFalse()
{
var s = new PyString("Foo");
Assert.False(PyLong.IsLongType(s));
}
