Python System.Int32() Examples
The following are 24
code examples of System.Int32().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
System
, or try the search function
.
.
Example #1
| Source File: test_class.py From ironpython2 with Apache License 2.0 | 6 votes |
|
def test_type_type_is_type(self):
class OS: pass
class NS(object): pass
true_values = [type, NS, int, float, tuple, str]
if is_cli:
import System
true_values += [System.Boolean, System.Int32, System.Version, System.Exception]
for x in true_values:
self.assertTrue(type(x) is type)
false_values = [OS]
if is_cli:
false_values += [ System.Boolean(1), System.Int32(3), System.Version(0, 0), System.Exception() ]
for x in false_values:
self.assertTrue(type(x) is not type)
Example #2
| Source File: test_isinstance.py From ironpython3 with Apache License 2.0 | 6 votes |
|
def test_int_minvalue(self):
# Test for type of System.Int32.MinValue
self.assertEqual(type(-2147483648), int)
self.assertEqual(type(-(2147483648)), long)
self.assertEqual(type(-long(2147483648)), long)
self.assertEqual(type(-0x80000000), int)
self.assertEqual(type(int('-2147483648')), int)
self.assertEqual(type(int('-80000000', 16)), int)
self.assertEqual(type(int('-2147483649')), long)
self.assertEqual(type(int('-80000001', 16)), long)
if is_cli:
import clr
import System
# verify our str.split doesn't replace CLR's String.Split
chars = System.Array[str]([' '])
res = 'a b c'.Split(chars, System.StringSplitOptions.RemoveEmptyEntries)
self.assertEqual(res[0], 'a')
self.assertEqual(res[1], 'b')
self.assertEqual(res[2], 'c')
Example #3
| Source File: test_isinstance.py From ironpython2 with Apache License 2.0 | 6 votes |
|
def test_int_minvalue(self):
# Test for type of System.Int32.MinValue
self.assertEqual(type(-2147483648), int)
self.assertEqual(type(-(2147483648)), long)
self.assertEqual(type(-2147483648L), long)
self.assertEqual(type(-0x80000000), int)
self.assertEqual(type(int('-2147483648')), int)
self.assertEqual(type(int('-80000000', 16)), int)
self.assertEqual(type(int('-2147483649')), long)
self.assertEqual(type(int('-80000001', 16)), long)
if is_cli:
import clr
import System
# verify our str.split doesn't replace CLR's String.Split
chars = System.Array[str]([' '])
res = 'a b c'.Split(chars, System.StringSplitOptions.RemoveEmptyEntries)
self.assertEqual(res[0], 'a')
self.assertEqual(res[1], 'b')
self.assertEqual(res[2], 'c')
Example #4
| Source File: test_class.py From ironpython3 with Apache License 2.0 | 6 votes |
|
def test_type_type_is_type(self):
class OS: pass
class NS(object): pass
true_values = [type, NS, int, float, tuple, str]
if is_cli:
import System
true_values += [System.Boolean, System.Int32, System.Version, System.Exception]
for x in true_values:
self.assertTrue(type(x) is type)
false_values = [OS]
if is_cli:
false_values += [ System.Boolean(1), System.Int32(3), System.Version(0, 0), System.Exception() ]
for x in false_values:
self.assertTrue(type(x) is not type)
Example #5
| Source File: test_ironmath.py From ironpython3 with Apache License 2.0 | 5 votes |
|
def test_big_1(self):
from System import SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64
from System.Numerics import BigInteger
for (a, m, t,x) in [
(7, "ToSByte", SByte,2),
(8, "ToByte", Byte, 0),
(15, "ToInt16", Int16,2),
(16, "ToUInt16", UInt16,0),
(31, "ToInt32", Int32,2),
(32, "ToUInt32", UInt32,0),
(63, "ToInt64", Int64,2),
(64, "ToUInt64", UInt64,0)
]:
b = BigInteger(-x ** a )
left = getattr(b, m)(self.p)
right = t.MinValue
self.assertEqual(left, right)
b = BigInteger(2 ** a -1)
left = getattr(b, m)(self.p)
right = t.MaxValue
self.assertEqual(left, right)
b = BigInteger(long(0))
left = getattr(b, m)(self.p)
right = t.MaxValue - t.MaxValue
self.assertEqual(left, 0)
self.assertRaises(OverflowError,getattr(BigInteger(2 ** a ), m),self.p)
self.assertRaises(OverflowError,getattr(BigInteger(-1 - x ** a ), m),self.p)
Example #6
| Source File: test_array.py From ironpython3 with Apache License 2.0 | 5 votes |
|
def test_constructor(self):
array1 = System.Array[int](10)
array2 = System.Array.CreateInstance(System.Int32, 10)
self.assertEquals(len(array1), len(array2))
for i in range(len(array1)):
self.assertEquals(array1[i], 0)
self.assertEquals(array1[i], array2[i])
# 2-dimensional
array3 = System.Array[System.Byte](3, 4)
self.assertEquals(array3.Rank, 2)
for x in range(array3.GetLength(0)):
for y in range(array3.GetLength(1)):
self.assertEquals(array3[x, y], 0)
Example #7
| Source File: test_ironmath.py From ironpython3 with Apache License 2.0 | 5 votes |
|
def test_big_2(self):
from System import Int32, UInt32, Int64, UInt64
from System.Numerics import BigInteger
for (a, m, t,x) in [
(31, "ToInt32",Int32,2),
(32, "ToUInt32",UInt32,0),
(63, "ToInt64",Int64,2),
(64, "ToUInt64",UInt64,0)
]:
b = BigInteger(-x ** a )
left = getattr(b, m)()
right = t.MinValue
self.assertEqual(left, right)
b = BigInteger(2 ** a -1)
left = getattr(b, m)()
right = t.MaxValue
self.assertEqual(left, right)
b = BigInteger(long(0))
left = getattr(b, m)()
right = t.MaxValue - t.MaxValue
self.assertEqual(left, right)
self.assertRaises(OverflowError,getattr(BigInteger(2 ** a ), m))
self.assertRaises(OverflowError,getattr(BigInteger(-1 - x ** a ), m))
Example #8
| Source File: test_numtypes.py From ironpython3 with Apache License 2.0 | 5 votes |
|
def validate_constructors(self, values):
types = [Byte, UInt16, UInt32, UInt64, SByte, Int16, Int32, Int64]
total = 0
for value in values:
for first in types:
v1 = first(value)
for second in types:
v2 = first(second((value)))
total += 1
return total
Example #9
| Source File: test_numtypes.py From ironpython3 with Apache License 2.0 | 5 votes |
|
def get_values(values, itypes, ftypes):
"""
This will return structure of values converted to variety of types as a list of tuples:
[ ...
( python_value, [ all_values ] ),
... ]
all_values: Byte, UInt16, UInt32, UInt64, SByte, Int16, Int32, Int64, Single, Double, myint, mylong, myfloat
"""
all = []
for v in values:
sv = str(v)
py = int(v)
clr = get_clr_values(sv, itypes)
clr.append(long(py))
clr.append(myint(py))
clr.append(mylong(py))
all.append( (py, clr) )
py = long(v)
clr = get_clr_values(sv, itypes)
clr.append(py)
clr.append(myint(py))
clr.append(mylong(py))
all.append( (py, clr) )
py = float(v)
clr = get_clr_values(sv, ftypes)
clr.append(myfloat(py))
all.append( (py, clr) )
for imag in [0j, 1j, -1j]:
py = complex(v + imag)
all.append( (py, [ py, mycomplex(py) ] ) )
all.append( (True, [ True ] ))
all.append( (False, [ False ] ))
return all
Example #10
| Source File: __init__.py From PyESAPI with MIT License | 5 votes |
|
def image_to_nparray(image_like):
'''returns a 3D numpy.ndarray of floats indexed like [x,y,z]'''
_shape = (image_like.XSize, image_like.YSize, image_like.ZSize)
_array = np.zeros(_shape)
_buffer = Array.CreateInstance(Int32, image_like.XSize, image_like.YSize)
for z in range(image_like.ZSize):
image_like.GetVoxels(z, _buffer)
_array[:, :, z] = to_ndarray(_buffer, dtype=c_int32).reshape((image_like.XSize, image_like.YSize))
return _array
Example #11
| Source File: win32_user32.py From RevitBatchProcessor with GNU General Public License v3.0 | 5 votes |
|
def GetWindowThreadProcessId(hwnd):
processId = 0
pProcessId = Interop.Marshal.AllocHGlobal(Interop.Marshal.SizeOf(processId))
Interop.Marshal.StructureToPtr(processId, pProcessId, False)
threadId = Win32_GetWindowThreadProcessId(hwnd, pProcessId)
if threadId != 0:
processId = Interop.Marshal.PtrToStructure[System.Int32](pProcessId)
Interop.Marshal.FreeHGlobal(pProcessId)
return threadId, processId
Example #12
| Source File: test_index.py From ironpython2 with Apache License 2.0 | 5 votes |
|
def test_multidim_array(self):
import clr
import System
md = System.Array.CreateInstance(System.Int32, 2, 2, 2)
for i in range(2):
for j in range(2):
for k in range(2):
md[i,j,k] = i+j+k
for i in range(2):
for j in range(2):
for k in range(2):
self.assertTrue(md[i,j,k] == i+j+k)
Example #13
| Source File: test_ironmath.py From ironpython2 with Apache License 2.0 | 5 votes |
|
def test_big_2(self):
from System import Int32, UInt32, Int64, UInt64
from System.Numerics import BigInteger
for (a, m, t,x) in [
(31, "ToInt32",Int32,2),
(32, "ToUInt32",UInt32,0),
(63, "ToInt64",Int64,2),
(64, "ToUInt64",UInt64,0)
]:
b = BigInteger(-x ** a )
left = getattr(b, m)()
right = t.MinValue
self.assertEqual(left, right)
b = BigInteger(2 ** a -1)
left = getattr(b, m)()
right = t.MaxValue
self.assertEqual(left, right)
b = BigInteger(long(0))
left = getattr(b, m)()
right = t.MaxValue - t.MaxValue
self.assertEqual(left, right)
self.assertRaises(OverflowError,getattr(BigInteger(2 ** a ), m))
self.assertRaises(OverflowError,getattr(BigInteger(-1 - x ** a ), m))
Example #14
| Source File: test_ironmath.py From ironpython2 with Apache License 2.0 | 5 votes |
|
def test_big_1(self):
from System import SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64
from System.Numerics import BigInteger
for (a, m, t,x) in [
(7, "ToSByte", SByte,2),
(8, "ToByte", Byte, 0),
(15, "ToInt16", Int16,2),
(16, "ToUInt16", UInt16,0),
(31, "ToInt32", Int32,2),
(32, "ToUInt32", UInt32,0),
(63, "ToInt64", Int64,2),
(64, "ToUInt64", UInt64,0)
]:
b = BigInteger(-x ** a )
left = getattr(b, m)(self.p)
right = t.MinValue
self.assertEqual(left, right)
b = BigInteger(2 ** a -1)
left = getattr(b, m)(self.p)
right = t.MaxValue
self.assertEqual(left, right)
b = BigInteger(long(0))
left = getattr(b, m)(self.p)
right = t.MaxValue - t.MaxValue
self.assertEqual(left, 0)
self.assertRaises(OverflowError,getattr(BigInteger(2 ** a ), m),self.p)
self.assertRaises(OverflowError,getattr(BigInteger(-1 - x ** a ), m),self.p)
Example #15
| Source File: test_helpers.py From mikeio with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def test_safe_length_returns_length_for_net_list():
a = List[Int32]()
a.Add(1)
a.Add(2)
a.Add(6)
n = safe_length(a)
assert n==3
Example #16
| Source File: test_numtypes.py From ironpython2 with Apache License 2.0 | 5 votes |
|
def validate_constructors(self, values):
types = [Byte, UInt16, UInt32, UInt64, SByte, Int16, Int32, Int64]
total = 0
for value in values:
for first in types:
v1 = first(value)
for second in types:
v2 = first(second((value)))
total += 1
return total
Example #17
| Source File: test_numtypes.py From ironpython2 with Apache License 2.0 | 5 votes |
|
def get_values(values, itypes, ftypes):
"""
This will return structure of values converted to variety of types as a list of tuples:
[ ...
( python_value, [ all_values ] ),
... ]
all_values: Byte, UInt16, UInt32, UInt64, SByte, Int16, Int32, Int64, Single, Double, myint, mylong, myfloat
"""
all = []
for v in values:
sv = str(v)
py = int(v)
clr = get_clr_values(sv, itypes)
clr.append(long(py))
clr.append(myint(py))
clr.append(mylong(py))
all.append( (py, clr) )
py = long(v)
clr = get_clr_values(sv, itypes)
clr.append(py)
clr.append(myint(py))
clr.append(mylong(py))
all.append( (py, clr) )
py = float(v)
clr = get_clr_values(sv, ftypes)
clr.append(myfloat(py))
all.append( (py, clr) )
for imag in [0j, 1j, -1j]:
py = complex(v + imag)
all.append( (py, [ py, mycomplex(py) ] ) )
all.append( (True, [ True ] ))
all.append( (False, [ False ] ))
return all
Example #18
| Source File: cominterop_util.py From ironpython2 with Apache License 2.0 | 4 votes |
|
def overflowErrorTrigger(in_type):
ret_val = {}
############################################################
ret_val["VARIANT_BOOL"] = []
############################################################
ret_val["BYTE"] = []
ret_val["BYTE"] += overflow_num_helper(System.Byte)
############################################################
#Doesn't seem possible to create a value (w/o 1st overflowing
#in Python) to pass to the COM method which will overflow.
ret_val["BSTR"] = [] #["0123456789" * 1234567890]
############################################################
ret_val["CHAR"] = []
ret_val["CHAR"] += overflow_num_helper(System.SByte)
############################################################
ret_val["FLOAT"] = []
ret_val["FLOAT"] += overflow_num_helper(System.Double)
#Shouldn't be possible to overflow a double.
ret_val["DOUBLE"] = []
############################################################
ret_val["USHORT"] = []
ret_val["USHORT"] += overflow_num_helper(System.UInt16)
ret_val["ULONG"] = []
ret_val["ULONG"] += overflow_num_helper(System.UInt32)
ret_val["ULONGLONG"] = []
# Dev10 475426
#ret_val["ULONGLONG"] += overflow_num_helper(System.UInt64)
ret_val["SHORT"] = []
ret_val["SHORT"] += overflow_num_helper(System.Int16)
ret_val["LONG"] = []
# Dev10 475426
#ret_val["LONG"] += overflow_num_helper(System.Int32)
ret_val["LONGLONG"] = []
# Dev10 475426
#ret_val["LONGLONG"] += overflow_num_helper(System.Int64)
############################################################
return ret_val[in_type]
Example #19
| Source File: dotnet.py From mikeio with BSD 3-Clause "New" or "Revised" License | 4 votes |
|
def to_dotnet_array(x):
"""
Convert numpy array to .NET array with same data type (single, double,...)
Parameters
----------
x: np.array
Returns
-------
System.Array
Notes
-----
Given a `numpy.ndarray` returns a CLR `System.Array`. See _MAP_NP_NET for
the mapping of Numpy dtypes to CLR types.
"""
dims = x.shape
dtype = x.dtype
netDims = System.Array.CreateInstance(System.Int32, x.ndim)
for I in range(x.ndim):
netDims[I] = System.Int32(dims[I])
if not x.flags.c_contiguous:
x = x.copy(order="C")
assert x.flags.c_contiguous
try:
netArray = System.Array.CreateInstance(_MAP_NP_NET[dtype], netDims)
except KeyError:
raise NotImplementedError(
"asNetArray does not yet support dtype {}".format(dtype)
)
try: # Memmove
destHandle = GCHandle.Alloc(netArray, GCHandleType.Pinned)
sourcePtr = x.__array_interface__["data"][0]
destPtr = destHandle.AddrOfPinnedObject().ToInt64()
ctypes.memmove(destPtr, sourcePtr, x.nbytes)
finally:
if destHandle.IsAllocated:
destHandle.Free()
return netArray
Example #20
| Source File: test___clrtype.py From ironpython3 with Apache License 2.0 | 4 votes |
|
def test_clrtype_returns_existing_clr_types(self):
'''
Our implementation of __clrtype__ returns existing .NET types
instead of subclassing from type or System.Type.
'''
global called
import clr
import System
if is_netcoreapp:
clr.AddReference("System.Collections")
clr.AddReference("System.Data.Common")
else:
clr.AddReference("System.Data")
types = [
System.Byte,
System.Int16,
System.UInt32,
System.Int32,
System.Int64,
System.Double,
System.Data.CommandType,
System.Data.Common.DataAdapter,
System.Boolean,
System.Char,
System.Decimal,
System.IntPtr,
System.Object,
System.String,
System.Collections.BitArray,
System.Collections.Generic.List[System.Char],
]
for x in types:
called = False
class MyType(type):
def __clrtype__(self):
global called
called = True
return x
class X(object):
__metaclass__ = MyType
self.assertEqual(called, True)
Example #21
| Source File: test_clrnuminterop.py From ironpython3 with Apache License 2.0 | 4 votes |
|
def test_sanity(self):
'''Make sure that numbers within the constraints of the numerical types are allowed.'''
import clr
import System
temp_list = [ ["System.Byte", 0, 255],
["System.SByte", -128, 127],
["System.Byte", 0, 255],
["System.Int16", -32768, 32767],
["System.UInt16", 0, 65535],
["System.Int32", -2147483648, 2147483647],
["System.UInt32", 0, 4294967295],
["System.Int64", -9223372036854775808, 9223372036854775807],
["System.UInt64", 0, 18446744073709551615],
["System.Single", -3.40282e+038, 3.40282e+038],
["System.Double", -1.79769313486e+308, 1.79769313486e+308],
["System.Decimal", -79228162514264337593543950335, 79228162514264337593543950335],
["int", -2147483648, 2147483647]
]
for num_type, small_val, large_val in temp_list:
self.assertTrue(self.num_ok_for_type(1, num_type))
self.assertTrue(self.num_ok_for_type(1.0, num_type))
#Minimum value
self.assertTrue(self.num_ok_for_type(small_val, num_type))
self.assertTrue(self.num_ok_for_type(small_val + 1, num_type))
self.assertTrue(self.num_ok_for_type(small_val + 2, num_type))
#Maximum value
self.assertTrue(self.num_ok_for_type(large_val, num_type))
self.assertTrue(self.num_ok_for_type(large_val - 1, num_type))
self.assertTrue(self.num_ok_for_type(large_val - 2, num_type))
#Negative cases
if num_type!="System.Single" and num_type!="System.Double" and num_type!="System.Decimal":
self.assertTrue(not self.num_ok_for_type(small_val - 1, num_type))
self.assertTrue(not self.num_ok_for_type(small_val - 2, num_type))
self.assertTrue(not self.num_ok_for_type(large_val + 1, num_type))
self.assertTrue(not self.num_ok_for_type(large_val + 2, num_type))
#Special cases
self.assertTrue(self.num_ok_for_type(0, "long"))
self.assertTrue(self.num_ok_for_type(1, "long"))
self.assertTrue(self.num_ok_for_type(-1, "long"))
self.assertTrue(self.num_ok_for_type(5, "long"))
self.assertTrue(self.num_ok_for_type(-92233720368547758080000, "long"))
self.assertTrue(self.num_ok_for_type( 18446744073709551615000, "long"))
self.assertTrue(self.num_ok_for_type(0.0, "float"))
self.assertTrue(self.num_ok_for_type(1.0, "float"))
self.assertTrue(self.num_ok_for_type(-1.0, "float"))
self.assertTrue(self.num_ok_for_type(3.14, "float"))
self.assertTrue(self.num_ok_for_type(-92233720368547758080000.0, "float"))
self.assertTrue(self.num_ok_for_type( 18446744073709551615000.0, "float"))
Example #22
| Source File: cominterop_util.py From ironpython3 with Apache License 2.0 | 4 votes |
|
def overflowErrorTrigger(in_type):
ret_val = {}
############################################################
ret_val["VARIANT_BOOL"] = []
############################################################
ret_val["BYTE"] = []
ret_val["BYTE"] += overflow_num_helper(System.Byte)
############################################################
#Doesn't seem possible to create a value (w/o 1st overflowing
#in Python) to pass to the COM method which will overflow.
ret_val["BSTR"] = [] #["0123456789" * 1234567890]
############################################################
ret_val["CHAR"] = []
ret_val["CHAR"] += overflow_num_helper(System.SByte)
############################################################
ret_val["FLOAT"] = []
ret_val["FLOAT"] += overflow_num_helper(System.Double)
#Shouldn't be possible to overflow a double.
ret_val["DOUBLE"] = []
############################################################
ret_val["USHORT"] = []
ret_val["USHORT"] += overflow_num_helper(System.UInt16)
ret_val["ULONG"] = []
ret_val["ULONG"] += overflow_num_helper(System.UInt32)
ret_val["ULONGLONG"] = []
# Dev10 475426
#ret_val["ULONGLONG"] += overflow_num_helper(System.UInt64)
ret_val["SHORT"] = []
ret_val["SHORT"] += overflow_num_helper(System.Int16)
ret_val["LONG"] = []
# Dev10 475426
#ret_val["LONG"] += overflow_num_helper(System.Int32)
ret_val["LONGLONG"] = []
# Dev10 475426
#ret_val["LONGLONG"] += overflow_num_helper(System.Int64)
############################################################
return ret_val[in_type]
Example #23
| Source File: test___clrtype__.py From ironpython2 with Apache License 2.0 | 4 votes |
|
def test_clrtype_returns_existing_clr_types(self):
'''
Our implementation of __clrtype__ returns existing .NET types
instead of subclassing from type or System.Type.
'''
global called
import clr
import System
if is_netcoreapp:
clr.AddReference("System.Collections")
clr.AddReference("System.Data.Common")
else:
clr.AddReference("System.Data")
types = [
System.Byte,
System.Int16,
System.UInt32,
System.Int32,
System.Int64,
System.Double,
System.Data.CommandType,
System.Data.Common.DataAdapter,
System.Boolean,
System.Char,
System.Decimal,
System.IntPtr,
System.Object,
System.String,
System.Collections.BitArray,
System.Collections.Generic.List[System.Char],
]
for x in types:
called = False
class MyType(type):
def __clrtype__(self):
global called
called = True
return x
class X(object):
__metaclass__ = MyType
self.assertEqual(called, True)
Example #24
| Source File: test_clrnuminterop.py From ironpython2 with Apache License 2.0 | 4 votes |
|
def test_sanity(self):
'''Make sure that numbers within the constraints of the numerical types are allowed.'''
import clr
import System
temp_list = [ ["System.Byte", 0, 255],
["System.SByte", -128, 127],
["System.Byte", 0, 255],
["System.Int16", -32768, 32767],
["System.UInt16", 0, 65535],
["System.Int32", -2147483648, 2147483647],
["System.UInt32", 0, 4294967295],
["System.Int64", -9223372036854775808, 9223372036854775807],
["System.UInt64", 0, 18446744073709551615],
["System.Single", -3.40282e+038, 3.40282e+038],
["System.Double", -1.79769313486e+308, 1.79769313486e+308],
["System.Decimal", -79228162514264337593543950335, 79228162514264337593543950335],
["int", -2147483648, 2147483647]
]
for num_type, small_val, large_val in temp_list:
self.assertTrue(self.num_ok_for_type(1, num_type))
self.assertTrue(self.num_ok_for_type(1.0, num_type))
#Minimum value
self.assertTrue(self.num_ok_for_type(small_val, num_type))
self.assertTrue(self.num_ok_for_type(small_val + 1, num_type))
self.assertTrue(self.num_ok_for_type(small_val + 2, num_type))
#Maximum value
self.assertTrue(self.num_ok_for_type(large_val, num_type))
self.assertTrue(self.num_ok_for_type(large_val - 1, num_type))
self.assertTrue(self.num_ok_for_type(large_val - 2, num_type))
#Negative cases
if num_type!="System.Single" and num_type!="System.Double" and num_type!="System.Decimal":
self.assertTrue(not self.num_ok_for_type(small_val - 1, num_type))
self.assertTrue(not self.num_ok_for_type(small_val - 2, num_type))
self.assertTrue(not self.num_ok_for_type(large_val + 1, num_type))
self.assertTrue(not self.num_ok_for_type(large_val + 2, num_type))
#Special cases
self.assertTrue(self.num_ok_for_type(0, "long"))
self.assertTrue(self.num_ok_for_type(1, "long"))
self.assertTrue(self.num_ok_for_type(-1, "long"))
self.assertTrue(self.num_ok_for_type(5, "long"))
self.assertTrue(self.num_ok_for_type(-92233720368547758080000, "long"))
self.assertTrue(self.num_ok_for_type( 18446744073709551615000, "long"))
self.assertTrue(self.num_ok_for_type(0.0, "float"))
self.assertTrue(self.num_ok_for_type(1.0, "float"))
self.assertTrue(self.num_ok_for_type(-1.0, "float"))
self.assertTrue(self.num_ok_for_type(3.14, "float"))
self.assertTrue(self.num_ok_for_type(-92233720368547758080000.0, "float"))
self.assertTrue(self.num_ok_for_type( 18446744073709551615000.0, "float"))
