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)); }