def test_equal(self) -> None:
data = lib.get_random_bytes(32)
sha256_1 = lt.sha256_hash(data)
sha256_2 = lt.sha256_hash(data)
self.assertEqual(sha256_1, sha256_2)
self.assertEqual(hash(sha256_1), hash(sha256_2))
def test_info_hash(self):
s1 = lt.sha1_hash(b'a' * 20)
s2 = lt.sha256_hash(b'b' * 32)
ih1 = lt.info_hash_t(s1)
self.assertTrue(ih1.has_v1())
self.assertFalse(ih1.has_v2())
self.assertEqual(ih1.v1, s1)
ih2 = lt.info_hash_t(s2)
self.assertFalse(ih2.has_v1())
self.assertTrue(ih2.has_v2())
self.assertEqual(ih2.v2, s2)
ih12 = lt.info_hash_t(s1, s2)
self.assertTrue(ih12.has_v1())
self.assertTrue(ih12.has_v2())
self.assertEqual(ih12.v1, s1)
self.assertEqual(ih12.v2, s2)
self.assertNotEqual(hash(ih1), hash(ih2))
self.assertNotEqual(hash(ih1), hash(ih12))
self.assertEqual(hash(ih1), hash(lt.info_hash_t(s1)))
self.assertEqual(hash(ih2), hash(lt.info_hash_t(s2)))
self.assertEqual(hash(ih12), hash(lt.info_hash_t(s1, s2)))
def test_sha1(self) -> None:
sha1 = lt.sha1_hash(lib.get_random_bytes(20))
ih = lt.info_hash_t(sha1)
self.assertEqual(ih.get(lt.protocol_version.V1), sha1)
self.assertEqual(ih.get(lt.protocol_version.V2), lt.sha1_hash())
self.assertEqual(ih.get_best(), sha1)
self.assertTrue(ih.has(lt.protocol_version.V1))
self.assertFalse(ih.has(lt.protocol_version.V2))
self.assertTrue(ih.has_v1())
self.assertFalse(ih.has_v2())
self.assertEqual(ih.v1, sha1)
self.assertEqual(ih.v2, lt.sha256_hash())
self.assertEqual(ih, lt.info_hash_t(sha1))
self.assertEqual(hash(ih), hash(lt.info_hash_t(sha1)))
self.assertNotEqual(ih, lt.info_hash_t())
def test_sha256(self) -> None:
sha256 = lt.sha256_hash(lib.get_random_bytes(32))
sha256_trunc = lt.sha1_hash(sha256.to_bytes()[:20])
ih = lt.info_hash_t(sha256)
self.assertEqual(ih.get(lt.protocol_version.V1), lt.sha1_hash())
self.assertEqual(ih.get(lt.protocol_version.V2), sha256_trunc)
self.assertEqual(ih.get_best(), sha256_trunc)
self.assertFalse(ih.has(lt.protocol_version.V1))
self.assertTrue(ih.has(lt.protocol_version.V2))
self.assertFalse(ih.has_v1())
self.assertTrue(ih.has_v2())
self.assertEqual(ih.v1, lt.sha1_hash())
self.assertEqual(ih.v2, sha256)
self.assertEqual(ih, lt.info_hash_t(sha256))
self.assertEqual(hash(ih), hash(lt.info_hash_t(sha256)))
self.assertNotEqual(ih, lt.info_hash_t())
def test_dual(self) -> None:
sha1 = lt.sha1_hash(lib.get_random_bytes(20))
sha256 = lt.sha256_hash(lib.get_random_bytes(32)) # type: ignore
ih = lt.info_hash_t(sha1, sha256) # type: ignore
self.assertEqual(ih.get(lt.protocol_version.V1), sha1)
self.assertEqual(ih.get(lt.protocol_version.V2), sha256)
self.assertEqual(ih.get_best(), sha256)
self.assertTrue(ih.has(lt.protocol_version.V1))
self.assertTrue(ih.has(lt.protocol_version.V2))
self.assertTrue(ih.has_v1())
self.assertTrue(ih.has_v2())
self.assertEqual(ih.v1, sha1)
self.assertEqual(ih.v2, sha256)
self.assertEqual(ih, lt.info_hash_t(sha1, sha256)) # type: ignore
self.assertEqual(hash(ih),
hash(lt.info_hash_t(sha1, sha256))) # type: ignore
self.assertNotEqual(ih, lt.info_hash_t())
def test_add_torrent_info_hash(self):
s = lt.session(settings)
h = s.add_torrent({
'info_hash': b'a' * 20,
'info_hashes': b'a' * 32,
'save_path': '.'
})
time.sleep(1)
alerts = s.pop_alerts()
while len(alerts) > 0:
a = alerts.pop(0)
print(a)
self.assertTrue(h.is_valid())
self.assertEqual(
h.status().info_hashes,
lt.info_hash_t(lt.sha1_hash(b'a' * 20), lt.sha256_hash(b'a' * 32)))
def hash_from_digest(digest: bytes) -> Union[lt.sha1_hash, lt.sha256_hash]:
if len(digest) == 20:
return lt.sha1_hash(digest)
if len(digest) == 32:
return lt.sha256_hash(digest)
raise ValueError(digest)
def test_convert(self) -> None:
data = lib.get_random_bytes(32)
sha256 = lt.sha256_hash(data)
self.assertEqual(str(sha256), data.hex())
self.assertEqual(sha256.to_bytes(), data)
def test_sha1hash(self):
h = 'a0' * 32
s = lt.sha256_hash(binascii.unhexlify(h))
self.assertEqual(h, str(s))
def test_hash(self):
self.assertNotEqual(hash(lt.sha256_hash(b'b' * 32)),
hash(lt.sha256_hash(b'a' * 32)))
self.assertEqual(hash(lt.sha256_hash(b'b' * 32)),
hash(lt.sha256_hash(b'b' * 32)))
def test_init_bytes(self) -> None:
data = lib.get_random_bytes(32)
sha256 = lt.sha256_hash(data)
self.assertEqual(sha256.to_bytes(), data)
def test_torrent_info_sha256_overload(self):
ti = lt.torrent_info(lt.info_hash_t(lt.sha256_hash(b'a' * 32)))
self.assertEqual(ti.info_hashes().v2, lt.sha256_hash(b'a' * 32))
ti_copy = lt.torrent_info(ti)
self.assertEqual(ti_copy.info_hashes().v2, lt.sha256_hash(b'a' * 32))
def test_empty(self) -> None:
sha256 = lt.sha256_hash()
self.assertTrue(sha256.is_all_zeros())
def test_is_all_zeros(self) -> None:
sha256 = lt.sha256_hash(lib.get_random_bytes(32))
self.assertFalse(sha256.is_all_zeros())
sha256 = lt.sha256_hash(b"\0" * 32)
self.assertTrue(sha256.is_all_zeros())
def test_from_orm(self) -> None:
ih = lt.info_hash_t(lt.sha1_hash(b"\xaa" * 20),
lt.sha256_hash(b"\xbb" * 32))
info_hashes = ltmodels.InfoHashes.from_orm(ih)
self.assertEqual(info_hashes,
ltmodels.InfoHashes(v1="aa" * 20, v2="bb" * 32))
def test_clear(self) -> None:
sha256 = lt.sha256_hash(lib.get_random_bytes(32))
sha256.clear()
self.assertEqual(sha256.to_bytes(), b"\0" * 32)
def test_init_short_buffer(self) -> None:
with self.assertRaises(ValueError):
lt.sha256_hash(b"a" * 31)
def test_less_than(self) -> None:
sha256_1 = lt.sha256_hash(b"\0" * 32)
sha256_2 = lt.sha256_hash(b"\0" * 31 + b"\1")
self.assertLess(sha256_1, sha256_2)
def test_not_equal(self) -> None:
sha256_1 = lt.sha256_hash(lib.get_random_bytes(32))
sha256_2 = lt.sha256_hash(lib.get_random_bytes(32))
self.assertNotEqual(sha256_1, sha256_2)
def test_init_long_buffer_deprecated(self) -> None:
with self.assertWarns(DeprecationWarning):
sha256 = lt.sha256_hash(b"a" * 33)
self.assertEqual(sha256, lt.sha256_hash(b"a" * 32))
def test_init_str_deprecated(self) -> None:
with self.assertWarns(DeprecationWarning):
sha256 = lt.sha256_hash("a" * 32) # type: ignore
self.assertEqual(sha256, lt.sha256_hash(b"a" * 32))
def test_to_string(self) -> None:
sha256 = lt.sha256_hash(b"a" * 32)
self.assertEqual(sha256.to_string(), b"a" * 32)
def test_orm(self) -> None:
sha256 = lt.sha256_hash(b"\xaa" * 32)
model = self.Model(sha256=sha256)
self.assertEqual(model.sha256, "aa" * 32)
