vector_test.py 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934
  1. from collections.abc import Hashable, Sequence
  2. import os
  3. import pickle
  4. import pytest
  5. from pyrsistent._pvector import python_pvector
  6. @pytest.fixture(scope='session', params=['pyrsistent._pvector', 'pvectorc'])
  7. def pvector(request):
  8. if request.param == 'pvectorc' and os.environ.get('PYRSISTENT_NO_C_EXTENSION'):
  9. pytest.skip('Configured to not run tests for C extension')
  10. m = pytest.importorskip(request.param)
  11. if request.param == 'pyrsistent._pvector':
  12. return m.python_pvector
  13. return m.pvector
  14. def test_literalish_works():
  15. from pyrsistent import pvector, v
  16. assert v() is pvector()
  17. assert v(1, 2) == pvector([1, 2])
  18. def test_empty_initialization(pvector):
  19. seq = pvector()
  20. assert len(seq) == 0
  21. with pytest.raises(IndexError) as error:
  22. x = seq[0]
  23. assert str(error.value) == 'Index out of range: 0'
  24. def test_initialization_with_one_element(pvector):
  25. seq = pvector([3])
  26. assert len(seq) == 1
  27. assert seq[0] == 3
  28. def test_append_works_and_does_not_affect_original_within_tail(pvector):
  29. seq1 = pvector([3])
  30. seq2 = seq1.append(2)
  31. assert len(seq1) == 1
  32. assert seq1[0] == 3
  33. assert len(seq2) == 2
  34. assert seq2[0] == 3
  35. assert seq2[1] == 2
  36. def test_append_works_and_does_not_affect_original_outside_tail(pvector):
  37. original = pvector([])
  38. seq = original
  39. for x in range(33):
  40. seq = seq.append(x)
  41. assert len(seq) == 33
  42. assert seq[0] == 0
  43. assert seq[31] == 31
  44. assert seq[32] == 32
  45. assert len(original) == 0
  46. def test_append_when_root_overflows(pvector):
  47. seq = pvector([])
  48. for x in range(32 * 33):
  49. seq = seq.append(x)
  50. seq = seq.append(10001)
  51. for i in range(32 * 33):
  52. assert seq[i] == i
  53. assert seq[32 * 33] == 10001
  54. def test_multi_level_sequence(pvector):
  55. seq = pvector(range(8000))
  56. seq2 = seq.append(11)
  57. assert seq[5] == 5
  58. assert seq2[7373] == 7373
  59. assert seq2[8000] == 11
  60. def test_multi_level_sequence_from_iterator(pvector):
  61. seq = pvector(iter(range(8000)))
  62. seq2 = seq.append(11)
  63. assert seq[5] == 5
  64. assert seq2[7373] == 7373
  65. assert seq2[8000] == 11
  66. def test_random_insert_within_tail(pvector):
  67. seq = pvector([1, 2, 3])
  68. seq2 = seq.set(1, 4)
  69. assert seq2[1] == 4
  70. assert seq[1] == 2
  71. def test_random_insert_outside_tail(pvector):
  72. seq = pvector(range(20000))
  73. seq2 = seq.set(19000, 4)
  74. assert seq2[19000] == 4
  75. assert seq[19000] == 19000
  76. def test_insert_beyond_end(pvector):
  77. seq = pvector(range(2))
  78. seq2 = seq.set(2, 50)
  79. assert seq2[2] == 50
  80. with pytest.raises(IndexError) as error:
  81. seq2.set(19, 4)
  82. assert str(error.value) == 'Index out of range: 19'
  83. def test_insert_with_index_from_the_end(pvector):
  84. x = pvector([1, 2, 3, 4])
  85. assert x.set(-2, 5) == pvector([1, 2, 5, 4])
  86. def test_insert_with_too_negative_index(pvector):
  87. x = pvector([1, 2, 3, 4])
  88. with pytest.raises(IndexError):
  89. x.set(-5, 17)
  90. def test_iteration(pvector):
  91. y = 0
  92. seq = pvector(range(2000))
  93. for x in seq:
  94. assert x == y
  95. y += 1
  96. assert y == 2000
  97. def test_zero_extend(pvector):
  98. the_list = []
  99. seq = pvector()
  100. seq2 = seq.extend(the_list)
  101. assert seq == seq2
  102. def test_short_extend(pvector):
  103. # Extend within tail length
  104. the_list = [1, 2]
  105. seq = pvector()
  106. seq2 = seq.extend(the_list)
  107. assert len(seq2) == len(the_list)
  108. assert seq2[0] == the_list[0]
  109. assert seq2[1] == the_list[1]
  110. def test_long_extend(pvector):
  111. # Multi level extend
  112. seq = pvector()
  113. length = 2137
  114. # Extend from scratch
  115. seq2 = seq.extend(range(length))
  116. assert len(seq2) == length
  117. for i in range(length):
  118. assert seq2[i] == i
  119. # Extend already filled vector
  120. seq3 = seq2.extend(range(length, length + 5))
  121. assert len(seq3) == length + 5
  122. for i in range(length + 5):
  123. assert seq3[i] == i
  124. # Check that the original vector is still intact
  125. assert len(seq2) == length
  126. for i in range(length):
  127. assert seq2[i] == i
  128. def test_slicing_zero_length_range(pvector):
  129. seq = pvector(range(10))
  130. seq2 = seq[2:2]
  131. assert len(seq2) == 0
  132. def test_slicing_range(pvector):
  133. seq = pvector(range(10))
  134. seq2 = seq[2:4]
  135. assert list(seq2) == [2, 3]
  136. def test_slice_identity(pvector):
  137. # Pvector is immutable, no need to make a copy!
  138. seq = pvector(range(10))
  139. assert seq is seq[::]
  140. def test_slicing_range_with_step(pvector):
  141. seq = pvector(range(100))
  142. seq2 = seq[2:12:3]
  143. assert list(seq2) == [2, 5, 8, 11]
  144. def test_slicing_no_range_but_step(pvector):
  145. seq = pvector(range(10))
  146. seq2 = seq[::2]
  147. assert list(seq2) == [0, 2, 4, 6, 8]
  148. def test_slicing_reverse(pvector):
  149. seq = pvector(range(10))
  150. seq2 = seq[::-1]
  151. assert seq2[0] == 9
  152. assert seq2[1] == 8
  153. assert len(seq2) == 10
  154. seq3 = seq[-3: -7: -1]
  155. assert seq3[0] == 7
  156. assert seq3[3] == 4
  157. assert len(seq3) == 4
  158. def test_delete_index(pvector):
  159. seq = pvector([1, 2, 3])
  160. assert seq.delete(0) == pvector([2, 3])
  161. assert seq.delete(1) == pvector([1, 3])
  162. assert seq.delete(2) == pvector([1, 2])
  163. assert seq.delete(-1) == pvector([1, 2])
  164. assert seq.delete(-2) == pvector([1, 3])
  165. assert seq.delete(-3) == pvector([2, 3])
  166. def test_delete_index_out_of_bounds(pvector):
  167. with pytest.raises(IndexError):
  168. pvector([]).delete(0)
  169. with pytest.raises(IndexError):
  170. pvector([]).delete(-1)
  171. def test_delete_index_malformed(pvector):
  172. with pytest.raises(TypeError):
  173. pvector([]).delete('a')
  174. def test_delete_slice(pvector):
  175. seq = pvector(range(5))
  176. assert seq.delete(1, 4) == pvector([0, 4])
  177. assert seq.delete(4, 1) == seq
  178. assert seq.delete(0, 1) == pvector([1, 2, 3, 4])
  179. assert seq.delete(6, 8) == seq
  180. assert seq.delete(-1, 1) == seq
  181. assert seq.delete(1, -1) == pvector([0, 4])
  182. def test_remove(pvector):
  183. seq = pvector(range(5))
  184. assert seq.remove(3) == pvector([0, 1, 2, 4])
  185. def test_remove_first_only(pvector):
  186. seq = pvector([1, 2, 3, 2, 1])
  187. assert seq.remove(2) == pvector([1, 3, 2, 1])
  188. def test_remove_index_out_of_bounds(pvector):
  189. seq = pvector(range(5))
  190. with pytest.raises(ValueError) as err:
  191. seq.remove(5)
  192. assert 'not in' in str(err.value)
  193. def test_addition(pvector):
  194. v = pvector([1, 2]) + pvector([3, 4])
  195. assert list(v) == [1, 2, 3, 4]
  196. def test_sorted(pvector):
  197. seq = pvector([5, 2, 3, 1])
  198. assert [1, 2, 3, 5] == sorted(seq)
  199. def test_boolean_conversion(pvector):
  200. assert not bool(pvector())
  201. assert bool(pvector([1]))
  202. def test_access_with_negative_index(pvector):
  203. seq = pvector([1, 2, 3, 4])
  204. assert seq[-1] == 4
  205. assert seq[-4] == 1
  206. def test_index_error_positive(pvector):
  207. with pytest.raises(IndexError):
  208. pvector([1, 2, 3])[3]
  209. def test_index_error_negative(pvector):
  210. with pytest.raises(IndexError):
  211. pvector([1, 2, 3])[-4]
  212. def test_is_sequence(pvector):
  213. assert isinstance(pvector(), Sequence)
  214. def test_empty_repr(pvector):
  215. assert str(pvector()) == "pvector([])"
  216. def test_non_empty_repr(pvector):
  217. v = pvector([1, 2, 3])
  218. assert str(v) == "pvector([1, 2, 3])"
  219. # There's some state that needs to be reset between calls in the native version,
  220. # test that multiple invocations work.
  221. assert str(v) == "pvector([1, 2, 3])"
  222. def test_repr_when_contained_object_contains_reference_to_self(pvector):
  223. x = [1, 2, 3]
  224. v = pvector([1, 2, x])
  225. x.append(v)
  226. assert str(v) == 'pvector([1, 2, [1, 2, 3, pvector([1, 2, [...]])]])'
  227. # Run a GC to provoke any potential misbehavior
  228. import gc
  229. gc.collect()
  230. def test_is_hashable(pvector):
  231. v = pvector([1, 2, 3])
  232. v2 = pvector([1, 2, 3])
  233. assert hash(v) == hash(v2)
  234. assert isinstance(pvector(), Hashable)
  235. def test_refuses_to_hash_when_members_are_unhashable(pvector):
  236. v = pvector([1, 2, [1, 2]])
  237. with pytest.raises(TypeError):
  238. hash(v)
  239. def test_compare_same_vectors(pvector):
  240. v = pvector([1, 2])
  241. assert v == v
  242. assert pvector() == pvector()
  243. def test_compare_with_other_type_of_object(pvector):
  244. assert pvector([1, 2]) != 'foo'
  245. def test_compare_equal_vectors(pvector):
  246. v1 = pvector([1, 2])
  247. v2 = pvector([1, 2])
  248. assert v1 == v2
  249. assert v1 >= v2
  250. assert v1 <= v2
  251. def test_compare_different_vectors_same_size(pvector):
  252. v1 = pvector([1, 2])
  253. v2 = pvector([1, 3])
  254. assert v1 != v2
  255. def test_compare_different_vectors_different_sizes(pvector):
  256. v1 = pvector([1, 2])
  257. v2 = pvector([1, 2, 3])
  258. assert v1 != v2
  259. def test_compare_lt_gt(pvector):
  260. v1 = pvector([1, 2])
  261. v2 = pvector([1, 2, 3])
  262. assert v1 < v2
  263. assert v2 > v1
  264. def test_repeat(pvector):
  265. v = pvector([1, 2])
  266. assert 5 * pvector() is pvector()
  267. assert v is 1 * v
  268. assert 0 * v is pvector()
  269. assert 2 * pvector([1, 2]) == pvector([1, 2, 1, 2])
  270. assert -3 * pvector([1, 2]) is pvector()
  271. def test_transform_zero_key_length(pvector):
  272. x = pvector([1, 2])
  273. assert x.transform([], 3) == 3
  274. def test_transform_base_case(pvector):
  275. x = pvector([1, 2])
  276. assert x.transform([1], 3) == pvector([1, 3])
  277. def test_transform_nested_vectors(pvector):
  278. x = pvector([1, 2, pvector([3, 4]), 5])
  279. assert x.transform([2, 0], 999) == pvector([1, 2, pvector([999, 4]), 5])
  280. def test_transform_when_appending(pvector):
  281. from pyrsistent import m
  282. x = pvector([1, 2])
  283. assert x.transform([2, 'd'], 999) == pvector([1, 2, m(d=999)])
  284. def test_transform_index_error_out_range(pvector):
  285. x = pvector([1, 2, pvector([3, 4]), 5])
  286. with pytest.raises(IndexError):
  287. x.transform([2, 10], 999)
  288. def test_transform_index_error_wrong_type(pvector):
  289. x = pvector([1, 2, pvector([3, 4]), 5])
  290. with pytest.raises(TypeError):
  291. x.transform([2, 'foo'], 999)
  292. def test_transform_non_setable_type(pvector):
  293. x = pvector([1, 2, 5])
  294. with pytest.raises(TypeError):
  295. x.transform([2, 3], 999)
  296. def test_reverse(pvector):
  297. x = pvector([1, 2, 5])
  298. assert list(reversed(x)) == [5, 2, 1]
  299. def test_contains(pvector):
  300. x = pvector([1, 2, 5])
  301. assert 2 in x
  302. assert 3 not in x
  303. def test_index(pvector):
  304. x = pvector([1, 2, 5])
  305. assert x.index(5) == 2
  306. def test_index_not_found(pvector):
  307. x = pvector([1, 2, 5])
  308. with pytest.raises(ValueError):
  309. x.index(7)
  310. def test_index_not_found_with_limits(pvector):
  311. x = pvector([1, 2, 5, 1])
  312. with pytest.raises(ValueError):
  313. x.index(1, 1, 3)
  314. def test_count(pvector):
  315. x = pvector([1, 2, 5, 1])
  316. assert x.count(1) == 2
  317. assert x.count(4) == 0
  318. def test_empty_truthiness(pvector):
  319. assert pvector([1])
  320. assert not pvector([])
  321. def test_pickling_empty_vector(pvector):
  322. assert pickle.loads(pickle.dumps(pvector(), -1)) == pvector()
  323. def test_pickling_non_empty_vector(pvector):
  324. assert pickle.loads(pickle.dumps(pvector([1, 'a']), -1)) == pvector([1, 'a'])
  325. def test_mset_basic_assignments(pvector):
  326. v1 = pvector(range(2000))
  327. v2 = v1.mset(1, -1, 505, -505, 1998, -1998)
  328. # Original not changed
  329. assert v1[1] == 1
  330. assert v1[505] == 505
  331. assert v1[1998] == 1998
  332. # Other updated
  333. assert v2[1] == -1
  334. assert v2[505] == -505
  335. assert v2[1998] == -1998
  336. def test_mset_odd_number_of_arguments(pvector):
  337. v = pvector([0, 1])
  338. with pytest.raises(TypeError):
  339. v.mset(0, 10, 1)
  340. def test_mset_index_out_of_range(pvector):
  341. v = pvector([0, 1])
  342. with pytest.raises(IndexError):
  343. v.mset(3, 10)
  344. def test_evolver_no_update(pvector):
  345. # This is mostly a test against memory leaks in the C implementation
  346. v = pvector(range(40))
  347. assert v.evolver().persistent() == v
  348. def test_evolver_deallocate_dirty_evolver(pvector):
  349. # Ref count handling in native implementation
  350. v = pvector(range(3220))
  351. e = v.evolver()
  352. e[10] = -10
  353. e[3220] = -3220
  354. def test_evolver_simple_update_in_tree(pvector):
  355. v = pvector(range(35))
  356. e = v.evolver()
  357. e[10] = -10
  358. assert e[10] == -10
  359. assert e.persistent()[10] == -10
  360. def test_evolver_set_out_of_range(pvector):
  361. v = pvector([0])
  362. e = v.evolver()
  363. with pytest.raises(IndexError) as error:
  364. e[10] = 1
  365. assert str(error.value) == "Index out of range: 10"
  366. def test_evolver_multi_level_multi_update_in_tree(pvector):
  367. # This test is mostly to detect memory/ref count issues in the native implementation
  368. v = pvector(range(3500))
  369. e = v.evolver()
  370. # Update differs between first and second time since the
  371. # corresponding node will be marked as dirty the first time only.
  372. e[10] = -10
  373. e[11] = -11
  374. e[10] = -1000
  375. # Update in neighbour node
  376. e[50] = -50
  377. e[50] = -5000
  378. # Update in node in other half of vector
  379. e[3000] = -3000
  380. e[3000] = -30000
  381. # Before freezing
  382. assert e[10] == -1000
  383. assert e[11] == -11
  384. assert e[50] == -5000
  385. assert e[3000] == -30000
  386. # Run a GC to provoke any potential misbehavior
  387. import gc
  388. gc.collect()
  389. v2 = e.persistent()
  390. assert v2[10] == -1000
  391. assert v2[50] == -5000
  392. assert v2[3000] == -30000
  393. # Run a GC to provoke any potential misbehavior
  394. gc.collect()
  395. # After freezing
  396. assert e[10] == -1000
  397. assert e[11] == -11
  398. assert e[50] == -5000
  399. assert e[3000] == -30000
  400. # Original stays the same
  401. assert v[10] == 10
  402. assert v[50] == 50
  403. assert v[3000] == 3000
  404. def test_evolver_simple_update_in_tail(pvector):
  405. v = pvector(range(35))
  406. e = v.evolver()
  407. e[33] = -33
  408. assert e[33] == -33
  409. assert e.persistent()[33] == -33
  410. assert v[33] == 33
  411. def test_evolver_simple_update_just_outside_vector(pvector):
  412. v = pvector()
  413. e = v.evolver()
  414. e[0] = 1
  415. assert e[0] == 1
  416. assert e.persistent()[0] == 1
  417. assert len(v) == 0
  418. def test_evolver_append(pvector):
  419. v = pvector()
  420. e = v.evolver()
  421. e.append(1000)
  422. assert e[0] == 1000
  423. e[0] = 2000
  424. assert e[0] == 2000
  425. assert list(e.persistent()) == [2000]
  426. assert list(v) == []
  427. def test_evolver_extend(pvector):
  428. v = pvector([1000])
  429. e = v.evolver()
  430. e.extend([2000, 3000])
  431. e[2] = 20000
  432. assert list(e.persistent()) == [1000, 2000, 20000]
  433. assert list(v) == [1000]
  434. def test_evolver_assign_and_read_with_negative_indices(pvector):
  435. v = pvector([1, 2, 3])
  436. e = v.evolver()
  437. e[-1] = 4
  438. e.extend([11, 12, 13])
  439. e[-1] = 33
  440. assert e[-1] == 33
  441. assert list(e.persistent()) == [1, 2, 4, 11, 12, 33]
  442. def test_evolver_non_integral_access(pvector):
  443. e = pvector([1]).evolver()
  444. with pytest.raises(TypeError):
  445. x = e['foo']
  446. def test_evolver_non_integral_assignment(pvector):
  447. e = pvector([1]).evolver()
  448. with pytest.raises(TypeError):
  449. e['foo'] = 1
  450. def test_evolver_out_of_bounds_access(pvector):
  451. e = pvector([1]).evolver()
  452. with pytest.raises(IndexError):
  453. x = e[1]
  454. def test_evolver_out_of_bounds_assignment(pvector):
  455. e = pvector([1]).evolver()
  456. with pytest.raises(IndexError):
  457. e[2] = 1
  458. def test_no_dependencies_between_evolvers_from_the_same_pvector(pvector):
  459. original_list = list(range(40))
  460. v = pvector(original_list)
  461. e1 = v.evolver()
  462. e2 = v.evolver()
  463. e1.extend([1, 2, 3])
  464. e1[2] = 20
  465. e1[35] = 350
  466. e2.extend([-1, -2, -3])
  467. e2[2] = -20
  468. e2[35] = -350
  469. e1_expected = original_list + [1, 2, 3]
  470. e1_expected[2] = 20
  471. e1_expected[35] = 350
  472. assert list(e1.persistent()) == e1_expected
  473. e2_expected = original_list + [-1, -2, -3]
  474. e2_expected[2] = -20
  475. e2_expected[35] = -350
  476. assert list(e2.persistent()) == e2_expected
  477. def test_pvectors_produced_from_the_same_evolver_do_not_interfere(pvector):
  478. original_list = list(range(40))
  479. v = pvector(original_list)
  480. e = v.evolver()
  481. e.extend([1, 2, 3])
  482. e[2] = 20
  483. e[35] = 350
  484. v1 = e.persistent()
  485. v1_expected = original_list + [1, 2, 3]
  486. v1_expected[2] = 20
  487. v1_expected[35] = 350
  488. e.extend([-1, -2, -3])
  489. e[3] = -30
  490. e[36] = -360
  491. v2 = e.persistent()
  492. v2_expected = v1_expected + [-1, -2, -3]
  493. v2_expected[3] = -30
  494. v2_expected[36] = -360
  495. assert list(v1) == v1_expected
  496. assert list(v2) == v2_expected
  497. def test_evolver_len(pvector):
  498. e = pvector([1, 2, 3]).evolver()
  499. e.extend([4, 5])
  500. assert len(e) == 5
  501. def test_evolver_is_dirty(pvector):
  502. e = pvector([1, 2, 3]).evolver()
  503. assert not e.is_dirty()
  504. e.append(4)
  505. assert e.is_dirty
  506. e.persistent()
  507. assert not e.is_dirty()
  508. e[2] = 2000
  509. assert e.is_dirty
  510. e.persistent()
  511. assert not e.is_dirty()
  512. def test_vector_insert_one_step_beyond_end(pvector):
  513. # This test exists to get the transform functionality under memory
  514. # leak supervision. Most of the transformation tests are in test_transform.py.
  515. v = pvector([1, 2])
  516. assert v.transform([2], 3) == pvector([1, 2, 3])
  517. def test_evolver_with_no_updates_returns_same_pvector(pvector):
  518. v = pvector([1, 2])
  519. assert v.evolver().persistent() is v
  520. def test_evolver_returns_itself_on_evolving_operations(pvector):
  521. # Does this to be able to chain operations
  522. v = pvector([1, 2])
  523. assert v.evolver().append(3).extend([4, 5]).set(1, 6).persistent() == pvector([1, 6, 3, 4, 5])
  524. def test_evolver_delete_by_index(pvector):
  525. e = pvector([1, 2, 3]).evolver()
  526. del e[0]
  527. assert e.persistent() == python_pvector([2, 3])
  528. assert e.append(4).persistent() == python_pvector([2, 3, 4])
  529. def test_evolver_delete_function_by_index(pvector):
  530. e = pvector([1, 2, 3]).evolver()
  531. assert e.delete(1).persistent() == python_pvector([1, 3])
  532. def test_evolver_delete_function_by_index_multiple_times(pvector):
  533. SIZE = 40
  534. e = pvector(range(SIZE)).evolver()
  535. for i in range(SIZE):
  536. assert e[0] == i
  537. assert list(e.persistent()) == list(range(i, SIZE))
  538. del e[0]
  539. assert e.persistent() == list()
  540. def test_evolver_delete_function_invalid_index(pvector):
  541. e = pvector([1, 2]).evolver()
  542. with pytest.raises(TypeError):
  543. del e["e"]
  544. def test_delete_of_non_existing_element(pvector):
  545. e = pvector([1, 2]).evolver()
  546. with pytest.raises(IndexError):
  547. del e[2]
  548. del e[0]
  549. del e[0]
  550. with pytest.raises(IndexError):
  551. del e[0]
  552. assert e.persistent() == pvector()
  553. def test_append_followed_by_delete(pvector):
  554. e = pvector([1, 2]).evolver()
  555. e.append(3)
  556. del e[2]
  557. def test_evolver_set_followed_by_delete(pvector):
  558. evolver = pvector([1, 2]).evolver()
  559. evolver[1] = 3
  560. assert [evolver[i] for i in range(len(evolver))] == [1, 3]
  561. del evolver[0]
  562. assert evolver.persistent() == pvector([3])
  563. def test_compare_with_list(pvector):
  564. v = pvector([1, 2, 3])
  565. assert v == [1, 2, 3]
  566. assert v != [1, 2]
  567. assert v > [1, 2]
  568. assert v < [2, 2]
  569. assert [1, 2] < v
  570. assert v <= [1, 2, 3]
  571. assert v <= [1, 2, 4]
  572. assert v >= [1, 2, 3]
  573. assert v >= [1, 2]
  574. def test_compare_with_non_iterable(pvector):
  575. assert pvector([1, 2, 3]) != 5
  576. assert not (pvector([1, 2, 3]) == 5)
  577. def test_python_no_c_extension_with_environment_variable():
  578. from importlib import reload as reload_module
  579. import pyrsistent._pvector
  580. import pyrsistent
  581. import os
  582. os.environ['PYRSISTENT_NO_C_EXTENSION'] = 'TRUE'
  583. reload_module(pyrsistent._pvector)
  584. reload_module(pyrsistent)
  585. assert type(pyrsistent.pvector()) is pyrsistent._pvector.PythonPVector
  586. del os.environ['PYRSISTENT_NO_C_EXTENSION']
  587. reload_module(pyrsistent._pvector)
  588. reload_module(pyrsistent)
  589. def test_supports_weakref(pvector):
  590. import weakref
  591. weakref.ref(pvector())
  592. def test_get_evolver_referents(pvector):
  593. """The C implementation of the evolver should expose the original PVector
  594. to the gc only once.
  595. """
  596. if pvector.__module__ == 'pyrsistent._pvector':
  597. pytest.skip("This test only applies to pvectorc")
  598. import gc
  599. v = pvector([1, 2, 3])
  600. e = v.evolver()
  601. assert len([x for x in gc.get_referents(e) if x is v]) == 1
  602. def test_failing_repr(pvector):
  603. # See https://github.com/tobgu/pyrsistent/issues/84
  604. class A(object):
  605. def __repr__(self):
  606. raise ValueError('oh no!')
  607. with pytest.raises(ValueError):
  608. repr(pvector([A()]))
  609. def test_iterable(pvector):
  610. """
  611. PVectors can be created from iterables even though they can't be len()
  612. hinted.
  613. """
  614. assert pvector(iter("a")) == pvector(iter("a"))