add kikimr_configure

1 files changed, 174 insertions, 0 deletions

diff --git a/contrib/python/pyrsistent/py3/tests/freeze_test.py b/contrib/python/pyrsistent/py3/tests/freeze_test.py
new file mode 100644
index 0000000000..158cf5d872
--- /dev/null
+++ b/contrib/python/pyrsistent/py3/tests/freeze_test.py
@@ -0,0 +1,174 @@
+"""Tests for freeze and thaw."""
+import collections
+from pyrsistent import v, m, s, freeze, thaw, PRecord, field, mutant
+
+
+## Freeze (standard)
+
+def test_freeze_basic():
+    assert freeze(1) == 1
+    assert freeze('foo') == 'foo'
+
+def test_freeze_list():
+    assert freeze([1, 2]) == v(1, 2)
+
+def test_freeze_dict():
+    result = freeze({'a': 'b'})
+    assert result == m(a='b')
+    assert type(freeze({'a': 'b'})) is type(m())
+
+def test_freeze_defaultdict():
+    test_dict = collections.defaultdict(dict)
+    test_dict['a'] = 'b'
+    result = freeze(test_dict)
+    assert result == m(a='b')
+    assert type(freeze({'a': 'b'})) is type(m())
+
+def test_freeze_set():
+    result = freeze(set([1, 2, 3]))
+    assert result == s(1, 2, 3)
+    assert type(result) is type(s())
+
+def test_freeze_recurse_in_dictionary_values():
+    result = freeze({'a': [1]})
+    assert result == m(a=v(1))
+    assert type(result['a']) is type(v())
+
+def test_freeze_recurse_in_defaultdict_values():
+    test_dict = collections.defaultdict(dict)
+    test_dict['a'] = [1]
+    result = freeze(test_dict)
+    assert result == m(a=v(1))
+    assert type(result['a']) is type(v())
+
+def test_freeze_recurse_in_pmap_values():
+    input = {'a': m(b={'c': 1})}
+    result = freeze(input)
+    # PMap and PVector are == to their mutable equivalents
+    assert result == input
+    assert type(result) is type(m())
+    assert type(result['a']['b']) is type(m())
+
+def test_freeze_recurse_in_lists():
+    result = freeze(['a', {'b': 3}])
+    assert result == v('a', m(b=3))
+    assert type(result[1]) is type(m())
+
+def test_freeze_recurse_in_pvectors():
+    input = [1, v(2, [3])]
+    result = freeze(input)
+    # PMap and PVector are == to their mutable equivalents
+    assert result == input
+    assert type(result) is type(v())
+    assert type(result[1][1]) is type(v())
+
+def test_freeze_recurse_in_tuples():
+    """Values in tuples are recursively frozen."""
+    result = freeze(('a', {}))
+    assert result == ('a', m())
+    assert type(result[1]) is type(m())
+
+
+## Freeze (weak)
+
+def test_freeze_nonstrict_no_recurse_in_pmap_values():
+    input = {'a': m(b={'c': 1})}
+    result = freeze(input, strict=False)
+    # PMap and PVector are == to their mutable equivalents
+    assert result == input
+    assert type(result) is type(m())
+    assert type(result['a']['b']) is dict
+
+def test_freeze_nonstrict_no_recurse_in_pvectors():
+    input = [1, v(2, [3])]
+    result = freeze(input, strict=False)
+    # PMap and PVector are == to their mutable equivalents
+    assert result == input
+    assert type(result) is type(v())
+    assert type(result[1][1]) is list
+
+
+## Thaw
+
+def test_thaw_basic():
+    assert thaw(1) == 1
+    assert thaw('foo') == 'foo'
+
+def test_thaw_list():
+    result = thaw(v(1, 2))
+    assert result == [1, 2]
+    assert type(result) is list
+
+def test_thaw_dict():
+    result = thaw(m(a='b'))
+    assert result == {'a': 'b'}
+    assert type(result) is dict
+
+def test_thaw_set():
+    result = thaw(s(1, 2))
+    assert result == set([1, 2])
+    assert type(result) is set
+
+def test_thaw_recurse_in_mapping_values():
+    result = thaw(m(a=v(1)))
+    assert result == {'a': [1]}
+    assert type(result['a']) is list
+
+def test_thaw_recurse_in_dict_values():
+    result = thaw({'a': v(1, m(b=2))})
+    assert result == {'a': [1, {'b': 2}]}
+    assert type(result['a']) is list
+    assert type(result['a'][1]) is dict
+
+def test_thaw_recurse_in_vectors():
+    result = thaw(v('a', m(b=3)))
+    assert result == ['a', {'b': 3}]
+    assert type(result[1]) is dict
+
+def test_thaw_recurse_in_lists():
+    result = thaw(v(['a', m(b=1), v(2)]))
+    assert result == [['a', {'b': 1}, [2]]]
+    assert type(result[0]) is list
+    assert type(result[0][1]) is dict
+
+def test_thaw_recurse_in_tuples():
+    result = thaw(('a', m()))
+    assert result == ('a', {})
+    assert type(result[1]) is dict
+
+def test_thaw_can_handle_subclasses_of_persistent_base_types():
+    class R(PRecord):
+        x = field()
+
+    result = thaw(R(x=1))
+    assert result == {'x': 1}
+    assert type(result) is dict
+
+
+## Thaw (weak)
+
+def test_thaw_non_strict_no_recurse_in_dict_values():
+    result = thaw({'a': v(1, m(b=2))}, strict=False)
+    assert result == {'a': [1, {'b': 2}]}
+    assert type(result['a']) is type(v())
+    assert type(result['a'][1]) is type(m())
+
+def test_thaw_non_strict_no_recurse_in_lists():
+    result = thaw(v(['a', m(b=1), v(2)]), strict=False)
+    assert result == [['a', {'b': 1}, [2]]]
+    assert type(result[0][1]) is type(m())
+
+def test_mutant_decorator():
+    @mutant
+    def fn(a_list, a_dict):
+        assert a_list == v(1, 2, 3)
+        assert isinstance(a_dict, type(m()))
+        assert a_dict == {'a': 5}
+
+        return [1, 2, 3], {'a': 3}
+
+    pv, pm = fn([1, 2, 3], a_dict={'a': 5})
+
+    assert pv == v(1, 2, 3)
+    assert pm == m(a=3)
+    assert isinstance(pm, type(m()))