def test_send(client: sy.VirtualMachineClient) -> None:
syft_bool = Bool(5)
ptr = syft_bool.send(client)
# Check pointer type
assert ptr.__class__.__name__ == "BoolPointer"
# Check that we can get back the object
res = ptr.get()
assert res == syft_bool
def test_large_operands(self):
x = Range(10 ** 20, 10 ** 20 + 10, 3)
self.assertEqual(len(x), 4)
self.assertEqual(len(list(x)), 4)
x = Range(10 ** 20 + 10, 10 ** 20, 3)
self.assertEqual(len(x), 0)
self.assertEqual(len(list(x)), 0)
# self.assertFalse(x)
assert Bool(False) == x.__bool__()
x = Range(10 ** 20, 10 ** 20 + 10, -3)
self.assertEqual(len(x), 0)
self.assertEqual(len(list(x)), 0)
# self.assertFalse(x)
assert Bool(False) == x.__bool__()
x = Range(10 ** 20 + 10, 10 ** 20, -3)
self.assertEqual(len(x), 4)
self.assertEqual(len(list(x)), 4)
# self.assertTrue(x)
assert Bool(True) == x.__bool__()
# Now test Range() with longs
for x in [Range(-(2 ** 100)), Range(0, -(2 ** 100)), Range(0, 2 ** 100, -1)]:
self.assertEqual(list(x), [])
# self.assertFalse(x)
assert Bool(False) == x.__bool__()
a = int(10 * sys.maxsize)
b = int(100 * sys.maxsize)
c = int(50 * sys.maxsize)
self.assertEqual(list(Range(a, a + 2)), [a, a + 1])
self.assertEqual(list(Range(a + 2, a, -1)), [a + 2, a + 1])
self.assertEqual(list(Range(a + 4, a, -2)), [a + 4, a + 2])
seq = list(Range(a, b, c))
self.assertIn(a, seq)
self.assertNotIn(b, seq)
self.assertEqual(len(seq), 2)
self.assertEqual(seq[0], a)
self.assertEqual(seq[-1], a + c)
seq = list(Range(b, a, -c))
self.assertIn(b, seq)
self.assertNotIn(a, seq)
self.assertEqual(len(seq), 2)
self.assertEqual(seq[0], b)
self.assertEqual(seq[-1], b - c)
seq = list(Range(-a, -b, -c))
self.assertIn(-a, seq)
self.assertNotIn(-b, seq)
self.assertEqual(len(seq), 2)
self.assertEqual(seq[0], -a)
self.assertEqual(seq[-1], -a - c)
def test_serde() -> None:
syft_bool = Bool(True)
serialized = syft_bool._object2proto()
assert isinstance(serialized, Bool_PB)
deserialized = Bool._proto2object(proto=serialized)
assert isinstance(deserialized, Bool)
assert deserialized.id == syft_bool.id
assert deserialized == syft_bool
def test_convert() -> None:
assert Bool(10) == SyTrue
assert Bool(1) == SyTrue
assert Bool(-1) == SyTrue
assert Bool(0) == SyFalse
assert Bool("hello") == SyTrue
assert Bool("") == SyFalse
assert Bool() == SyFalse
def test_sane_len():
# this test just tests our assumptions about __len__
# this will start failing if __len__ changes assertions
for badval in [String("illegal"), Int(-1), Int(1 << 32)]:
class A:
def __len__(self):
return badval
try:
Bool(A())
except (Exception) as e_bool:
try:
len(A())
except (Exception) as e_len:
assert str(e_bool) == str(e_len)
def test_math() -> None:
assert +SyFalse == Int(0)
assert +SyFalse == SyFalse
assert -SyFalse == Int(0)
assert -SyFalse == SyFalse
assert abs(SyFalse) == Int(0)
assert abs(SyFalse) is not SyFalse
assert +SyTrue == Int(1)
assert +SyTrue is not SyTrue
assert -SyTrue == Int(-1)
assert abs(SyTrue) == Int(1)
assert abs(SyTrue) is not SyTrue
assert ~SyFalse == Int(-1)
assert ~SyTrue == Int(-2)
assert SyFalse + Int(2) == Int(2)
assert SyTrue + Int(2) == Int(3)
assert Int(2) + SyFalse == Int(2)
assert Int(2) + SyTrue == Int(3)
assert SyFalse + SyFalse == Int(0)
assert SyFalse + SyFalse is not SyFalse
assert SyFalse + SyTrue == Int(1)
assert SyFalse + SyTrue is not SyTrue
assert SyTrue + SyFalse == Int(1)
assert SyTrue + SyFalse is not SyTrue
assert SyTrue + SyTrue == Int(2)
assert SyTrue - SyTrue == Int(0)
assert SyTrue - SyTrue is not SyFalse
assert SyFalse - SyFalse == Int(0)
assert SyFalse - SyFalse is not SyFalse
assert SyTrue - SyFalse == Int(1)
assert SyTrue - SyFalse is not SyTrue
assert SyFalse - SyTrue == Int(-1)
assert SyTrue * Int(1) == Int(1)
assert SyFalse * Int(1) == Int(0)
assert SyFalse * Int(1) is not SyFalse
assert SyTrue / Int(1) == Int(1)
assert SyTrue / Int(1) is not SyTrue
assert SyFalse / Int(1) == Int(0)
assert SyFalse / Int(1) is not SyFalse
assert SyTrue % Int(1) == Int(0)
assert SyTrue % Int(1) is not SyFalse
assert SyTrue % Int(2) == Int(1)
assert SyTrue % Int(2) is not SyTrue
assert SyFalse % Int(1) == Int(0)
assert SyFalse % Int(1) is not SyFalse
for b in SyFalse, SyTrue:
for i in Int(0), Int(1), Int(2):
assert b**i == Int(b)**i
assert b**i is not Bool(Int(b)**i)
assert (Int(1) == Int(1)) == SyTrue
assert (Int(1) == Int(0)) == SyFalse
assert (Int(0) < Int(1)) == SyTrue
assert (Int(1) < Int(0)) == SyFalse
assert (Int(0) <= Int(0)) == SyTrue
assert (Int(1) <= Int(0)) == SyFalse
assert (Int(1) > Int(0)) == SyTrue
assert (Int(1) > Int(1)) == SyFalse
assert (Int(1) >= Int(1)) == SyTrue
assert (Int(0) >= Int(1)) == SyFalse
assert (Int(0) != Int(1)) == SyTrue
assert (Int(0) != Int(0)) == SyFalse
x = List([Int(1)])
assert (x == x) == SyTrue
assert (x == x) != SyFalse
assert (1 in x) == SyTrue
assert (0 in x) == SyFalse
assert (1 not in x) == SyFalse
assert (0 not in x) == SyTrue
x = Dict({Int(1): Int(2)})
assert (x is x) == SyTrue
assert (x is not x) == SyFalse
assert (Int(1) in x) == SyTrue
assert (Int(0) in x) == SyFalse
assert (Int(1) not in x) == SyFalse
assert (Int(0) not in x) == SyTrue
assert not SyTrue == SyFalse
assert not SyFalse == SyTrue
def test_to_bytes():
assert Bool.from_bytes(SyTrue.to_bytes(4, "big"), "big")
assert not Bool.from_bytes(SyFalse.to_bytes(4, "big"), "big")
def test_protobuf_schema():
assert Bool.get_protobuf_schema()
def test_from_bytes():
assert Bool.from_bytes(b"\x00" * 8, "big") == SyFalse
assert Bool.from_bytes(b"abcd", "little") == SyTrue
# syft absolute
from syft.lib.python.bool import Bool
from syft.lib.python.dict import Dict
from syft.lib.python.float import Float
from syft.lib.python.int import Int
from syft.lib.python.list import List
from syft.lib.python.string import String
from syft.lib.python.tuple import Tuple
SyFalse = Bool(False)
SyTrue = Bool(True)
PyFalse = False
PyTrue = True
def test_repr() -> None:
assert repr(SyFalse) == String("False")
assert repr(SyTrue) == String("True")
assert eval(repr(SyFalse)) == SyFalse
assert eval(repr(SyTrue)) == SyTrue
def test_str() -> None:
assert str(SyFalse) == String("False")
assert str(SyTrue) == String("True")
def test_int() -> None:
assert int(SyFalse) == Int(0)
assert int(SyFalse) is not SyFalse
def test_large_Range(self):
# Check long Ranges (len > sys.maxsize)
# len() is expected to fail due to limitations of the __len__ protocol
def _Range_len(x):
try:
length = len(x)
except OverflowError:
step = x[1] - x[0]
length = 1 + ((x[-1] - x[0]) // step)
return length
a = -sys.maxsize
b = sys.maxsize
expected_len = b - a
x = Range(a, b)
self.assertIn(a, x)
self.assertNotIn(b, x)
self.assertRaises(OverflowError, len, x)
assert Bool(True) == x.__bool__()
self.assertEqual(_Range_len(x), expected_len)
self.assertEqual(x[0], a)
idx = sys.maxsize + 1
self.assertEqual(x[idx], a + idx)
self.assertEqual(x[idx : idx + 1][0], a + idx) # noqa: E203
with self.assertRaises(IndexError):
x[-expected_len - 1]
with self.assertRaises(IndexError):
x[expected_len]
a = 0
b = 2 * sys.maxsize
expected_len = b - a
x = Range(a, b)
self.assertIn(a, x)
self.assertNotIn(b, x)
self.assertRaises(OverflowError, len, x)
assert Bool(True) == x.__bool__()
self.assertEqual(_Range_len(x), expected_len)
self.assertEqual(x[0], a)
idx = sys.maxsize + 1
self.assertEqual(x[idx], a + idx)
self.assertEqual(x[idx : idx + 1][0], a + idx) # noqa: E203
with self.assertRaises(IndexError):
x[-expected_len - 1]
with self.assertRaises(IndexError):
x[expected_len]
a = 0
b = sys.maxsize ** 10
c = 2 * sys.maxsize
expected_len = 1 + (b - a) // c
x = Range(a, b, c)
self.assertIn(a, x)
self.assertNotIn(b, x)
self.assertRaises(OverflowError, len, x)
assert Bool(True) == x.__bool__()
self.assertEqual(_Range_len(x), expected_len)
self.assertEqual(x[0], a)
idx = sys.maxsize + 1
self.assertEqual(x[idx], a + (idx * c))
self.assertEqual(x[idx : idx + 1][0], a + (idx * c)) # noqa: E203
with self.assertRaises(IndexError):
x[-expected_len - 1]
with self.assertRaises(IndexError):
x[expected_len]
a = sys.maxsize ** 10
b = 0
c = -2 * sys.maxsize
expected_len = 1 + (b - a) // c
x = Range(a, b, c)
self.assertIn(a, x)
self.assertNotIn(b, x)
self.assertRaises(OverflowError, len, x)
assert Bool(True) == x.__bool__()
self.assertEqual(_Range_len(x), expected_len)
self.assertEqual(x[0], a)
idx = sys.maxsize + 1
self.assertEqual(x[idx], a + (idx * c))
self.assertEqual(x[idx : idx + 1][0], a + (idx * c)) # noqa: E203
with self.assertRaises(IndexError):
x[-expected_len - 1]
with self.assertRaises(IndexError):
x[expected_len]