============================= test session starts ==============================
platform linux -- Python 3.10.1, pytest-6.2.5, py-1.11.0, pluggy-0.13.1
rootdir: /build/python-lmdb/src/py-lmdb-py-lmdb_1.2.1
collected 190 items

tests/crash_test.py FFFFFFFFFFFFFFFFFFF                                  [ 10%]
tests/cursor_test.py FFFFFFFFFFFFFFFFFFFFFFFFFFFFF                       [ 25%]
tests/env_test.py ....FFFFFFFFFFFF.FFFFF.FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF [ 53%]
FFFFFFFFFFFFFF                                                           [ 61%]
tests/getmulti_test.py FFFF                                              [ 63%]
tests/iteration_test.py FFFFFFFFFFFFFFFFFF                               [ 72%]
tests/package_test.py .                                                  [ 73%]
tests/tool_test.py FF                                                    [ 74%]
tests/txn_test.py FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF      [100%]

=================================== FAILURES ===================================
__________________________ CrashTest.testCloseWithTxn __________________________

self = <crash_test.CrashTest testMethod=testCloseWithTxn>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:55: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test3vbvgpku', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test3vbvgpku: Operation not supported

tests/testlib.py:86: Error
_______________________ CrashTest.testDbCloseActiveIter ________________________

self = <crash_test.CrashTest testMethod=testDbCloseActiveIter>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:55: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzcv2mx7d', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzcv2mx7d: Operation not supported

tests/testlib.py:86: Error
__________________________ CrashTest.testDoubleClose ___________________________

self = <crash_test.CrashTest testMethod=testDoubleClose>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:55: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test_27tgrgv', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test_27tgrgv: Operation not supported

tests/testlib.py:86: Error
____________________________ CrashTest.testOldCrash ____________________________

self = <crash_test.CrashTest testMethod=testOldCrash>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:55: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testqdm5el1r', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testqdm5el1r: Operation not supported

tests/testlib.py:86: Error
_______________________ CrashTest.testTxnCloseActiveIter _______________________

self = <crash_test.CrashTest testMethod=testTxnCloseActiveIter>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:55: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testvs96_af2', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testvs96_af2: Operation not supported

tests/testlib.py:86: Error
____________________________ IteratorTest.testEmpty ____________________________

self = <crash_test.IteratorTest testMethod=testEmpty>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testgvxmpv_f', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testgvxmpv_f: Operation not supported

tests/testlib.py:86: Error
___________________________ IteratorTest.testFilled ____________________________

self = <crash_test.IteratorTest testMethod=testFilled>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testqrn4y_u0', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testqrn4y_u0: Operation not supported

tests/testlib.py:86: Error
________________________ IteratorTest.testFilledSkipEof ________________________

self = <crash_test.IteratorTest testMethod=testFilledSkipEof>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test6yw3i7jy', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test6yw3i7jy: Operation not supported

tests/testlib.py:86: Error
______________________ IteratorTest.testFilledSkipForward ______________________

self = <crash_test.IteratorTest testMethod=testFilledSkipForward>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testfn4swsz8', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testfn4swsz8: Operation not supported

tests/testlib.py:86: Error
______________________ IteratorTest.testFilledSkipReverse ______________________

self = <crash_test.IteratorTest testMethod=testFilledSkipReverse>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testk1_0x2s5', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testk1_0x2s5: Operation not supported

tests/testlib.py:86: Error
_______________________ BigReverseTest.test_big_reverse ________________________

self = <crash_test.BigReverseTest testMethod=test_big_reverse>

    def test_big_reverse(self):
>       path, env = testlib.temp_env()

tests/crash_test.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testqdje5fe1', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testqdje5fe1: Operation not supported

tests/testlib.py:86: Error
_________________________ MultiCursorDeleteTest.test1 __________________________

self = <crash_test.MultiCursorDeleteTest testMethod=test1>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:144: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testxewuali6', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testxewuali6: Operation not supported

tests/testlib.py:86: Error
______________________ MultiCursorDeleteTest.test_monster ______________________

self = <crash_test.MultiCursorDeleteTest testMethod=test_monster>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/crash_test.py:144: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test54eh_hko', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test54eh_hko: Operation not supported

tests/testlib.py:86: Error
__________ TxnFullTest.test_17bf75b12eb94d9903cd62329048b146d5313bad ___________

self = <crash_test.TxnFullTest testMethod=test_17bf75b12eb94d9903cd62329048b146d5313bad>

    def test_17bf75b12eb94d9903cd62329048b146d5313bad(self):
        """
        me_txn0 previously cached MDB_TXN_ERROR permanently. Fixed by
        17bf75b12eb94d9903cd62329048b146d5313bad.
        """
>       path, env = testlib.temp_env(map_size=4096 * 9, sync=False, max_spare_txns=0)

tests/crash_test.py:196: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test3ep_vls3', max_dbs = 10
kwargs = {'map_size': 36864, 'max_spare_txns': 0, 'sync': False}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test3ep_vls3: Operation not supported

tests/testlib.py:86: Error
_________________ EmptyIterTest.test_python3_iternext_segfault _________________

self = <crash_test.EmptyIterTest testMethod=test_python3_iternext_segfault>

    def test_python3_iternext_segfault(self):
        # https://github.com/dw/py-lmdb/issues/105
>       _, env = testlib.temp_env()

tests/crash_test.py:215: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testvhs_tuyf', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testvhs_tuyf: Operation not supported

tests/testlib.py:86: Error
_____________________ MultiputTest.test_multiput_segfault ______________________

self = <crash_test.MultiputTest testMethod=test_multiput_segfault>

    def test_multiput_segfault(self):
        # http://github.com/jnwatson/py-lmdb/issues/173
>       _, env = testlib.temp_env()

tests/crash_test.py:230: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testz3aq3ooz', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testz3aq3ooz: Operation not supported

tests/testlib.py:86: Error
______________________ InvalidArgTest.test_duplicate_arg _______________________

self = <crash_test.InvalidArgTest testMethod=test_duplicate_arg>

    def test_duplicate_arg(self):
        # https://github.com/jnwatson/py-lmdb/issues/203
>       _, env = testlib.temp_env()

tests/crash_test.py:255: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testvi7wpdwj', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testvi7wpdwj: Operation not supported

tests/testlib.py:86: Error
____________________ BadCursorTest.test_cursor_open_failure ____________________

self = <crash_test.BadCursorTest testMethod=test_cursor_open_failure>

    def test_cursor_open_failure(self):
        '''
        Test the error path for when mdb_cursor_open fails
    
        Note:
            this only would crash if cpython is built with Py_TRACE_REFS
        '''
        # https://github.com/jnwatson/py-lmdb/issues/216
>       path, env = testlib.temp_env()

tests/crash_test.py:272: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testtgp3_7fm', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testtgp3_7fm: Operation not supported

tests/testlib.py:86: Error
_______________________ MapResizeTest.test_opendb_resize _______________________

self = <crash_test.MapResizeTest testMethod=test_opendb_resize>

    def test_opendb_resize(self):
        '''
        Test that we correctly handle a MDB_MAP_RESIZED in env.open_db.
    
        Would seg fault in cffi implementation
        '''
        mpctx = multiprocessing.get_context('spawn')
>       path, env = testlib.temp_env(max_dbs=10, map_size=32000)

tests/crash_test.py:309: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test1an7jfei', max_dbs = 10, kwargs = {'map_size': 32000}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test1an7jfei: Operation not supported

tests/testlib.py:86: Error
________________________ ContextManagerTest.test_crash _________________________

self = <cursor_test.ContextManagerTest testMethod=test_crash>

    def test_crash(self):
>       path, env = testlib.temp_env()

tests/cursor_test.py:48: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testkmht1oin', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testkmht1oin: Operation not supported

tests/testlib.py:86: Error
__________________________ ContextManagerTest.test_ok __________________________

self = <cursor_test.ContextManagerTest testMethod=test_ok>

    def test_ok(self):
>       path, env = testlib.temp_env()

tests/cursor_test.py:41: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testekuzo1rj', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testekuzo1rj: Operation not supported

tests/testlib.py:86: Error
_____________________________ CursorTest.testCount _____________________________

self = <cursor_test.CursorTest testMethod=testCount>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testbanmpp9j', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testbanmpp9j: Operation not supported

tests/testlib.py:86: Error
__________________________ CursorTest.testDeleteEmpty __________________________

self = <cursor_test.CursorTest testMethod=testDeleteEmpty>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testc9pi4hwb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testc9pi4hwb: Operation not supported

tests/testlib.py:86: Error
__________________________ CursorTest.testDeleteFirst __________________________

self = <cursor_test.CursorTest testMethod=testDeleteFirst>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testl4cultz0', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testl4cultz0: Operation not supported

tests/testlib.py:86: Error
__________________________ CursorTest.testDeleteLast ___________________________

self = <cursor_test.CursorTest testMethod=testDeleteLast>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testpbdkaam9', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testpbdkaam9: Operation not supported

tests/testlib.py:86: Error
__________________________ CursorTest.testFirstFilled __________________________

self = <cursor_test.CursorTest testMethod=testFirstFilled>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test9ifpbcga', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test9ifpbcga: Operation not supported

tests/testlib.py:86: Error
________________________ CursorTest.testFirstLastEmpty _________________________

self = <cursor_test.CursorTest testMethod=testFirstLastEmpty>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testk6ey6b9t', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testk6ey6b9t: Operation not supported

tests/testlib.py:86: Error
_______________________ CursorTest.testKeyValueItemEmpty _______________________

self = <cursor_test.CursorTest testMethod=testKeyValueItemEmpty>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testqhlpwm4q', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testqhlpwm4q: Operation not supported

tests/testlib.py:86: Error
__________________________ CursorTest.testLastFilled ___________________________

self = <cursor_test.CursorTest testMethod=testLastFilled>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testq4gequ2p', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testq4gequ2p: Operation not supported

tests/testlib.py:86: Error
______________________________ CursorTest.testPut ______________________________

self = <cursor_test.CursorTest testMethod=testPut>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testo67pdzy6', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testo67pdzy6: Operation not supported

tests/testlib.py:86: Error
____________________________ CursorTest.testSetKey _____________________________

self = <cursor_test.CursorTest testMethod=testSetKey>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4zbfjofb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4zbfjofb: Operation not supported

tests/testlib.py:86: Error
___________________________ CursorTest.testSetRange ____________________________

self = <cursor_test.CursorTest testMethod=testSetRange>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test3dr238gk', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test3dr238gk: Operation not supported

tests/testlib.py:86: Error
_______________________ CursorTest2.testIterWithDeletes ________________________

self = <cursor_test.CursorTest2 testMethod=testIterWithDeletes>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:150: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testik5gu2k1', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testik5gu2k1: Operation not supported

tests/testlib.py:86: Error
___________________________ PutmultiTest.test_2list ____________________________

self = <cursor_test.PutmultiTest testMethod=test_2list>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzjgj4vta', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzjgj4vta: Operation not supported

tests/testlib.py:86: Error
_______________________ PutmultiTest.test_2list_preserve _______________________

self = <cursor_test.PutmultiTest testMethod=test_2list_preserve>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testlwukghl_', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testlwukghl_: Operation not supported

tests/testlib.py:86: Error
__________________________ PutmultiTest.test_bad_seq1 __________________________

self = <cursor_test.PutmultiTest testMethod=test_bad_seq1>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testq_0kotof', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testq_0kotof: Operation not supported

tests/testlib.py:86: Error
__________________________ PutmultiTest.test_dupsort ___________________________

self = <cursor_test.PutmultiTest testMethod=test_dupsort>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testqxidu6l_', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testqxidu6l_: Operation not supported

tests/testlib.py:86: Error
_____________________ PutmultiTest.test_dupsort_put_append _____________________

self = <cursor_test.PutmultiTest testMethod=test_dupsort_put_append>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test8mcwwdq0', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test8mcwwdq0: Operation not supported

tests/testlib.py:86: Error
__________________ PutmultiTest.test_dupsort_putmulti_append ___________________

self = <cursor_test.PutmultiTest testMethod=test_dupsort_putmulti_append>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testy7k9ecoo', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testy7k9ecoo: Operation not supported

tests/testlib.py:86: Error
_________________________ PutmultiTest.test_empty_seq __________________________

self = <cursor_test.PutmultiTest testMethod=test_empty_seq>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testjf3m8h3v', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testjf3m8h3v: Operation not supported

tests/testlib.py:86: Error
___________________________ ReplaceTest.test_replace ___________________________

self = <cursor_test.ReplaceTest testMethod=test_replace>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test7bqlak1y', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test7bqlak1y: Operation not supported

tests/testlib.py:86: Error
________________________ ContextManagerTest2.test_close ________________________

self = <cursor_test.ContextManagerTest2 testMethod=test_close>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testio1zchl4', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testio1zchl4: Operation not supported

tests/testlib.py:86: Error
____________________ ContextManagerTest2.test_double_close _____________________

self = <cursor_test.ContextManagerTest2 testMethod=test_double_close>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test95d67n0i', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test95d67n0i: Operation not supported

tests/testlib.py:86: Error
________________________ ContextManagerTest2.test_enter ________________________

self = <cursor_test.ContextManagerTest2 testMethod=test_enter>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testh0zjuh71', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testh0zjuh71: Operation not supported

tests/testlib.py:86: Error
____________________ ContextManagerTest2.test_exit_failure _____________________

self = <cursor_test.ContextManagerTest2 testMethod=test_exit_failure>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testlqvuqhpo', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testlqvuqhpo: Operation not supported

tests/testlib.py:86: Error
____________________ ContextManagerTest2.test_exit_success _____________________

self = <cursor_test.ContextManagerTest2 testMethod=test_exit_success>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()

tests/cursor_test.py:64: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4bq1bbhp', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4bq1bbhp: Operation not supported

tests/testlib.py:86: Error
___________________________ PreloadTest.test_preload ___________________________

self = <cursor_test.PreloadTest testMethod=test_preload>, redo = False

    def setUp(self, redo=False):
        env_args = {'writemap': True, 'map_size': GiB}
        if not redo:
>           self.path, self.env = testlib.temp_env(**env_args)

tests/cursor_test.py:272: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testn7emn0e6', max_dbs = 10
kwargs = {'map_size': 1073741824, 'writemap': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testn7emn0e6: Operation not supported

tests/testlib.py:86: Error
___________________ CursorReadOnlyTest.test_cursor_readonly ____________________

self = <cursor_test.CursorReadOnlyTest testMethod=test_cursor_readonly>

    def test_cursor_readonly(self):
        '''
        Tests whether you can open a cursor on a sub-db at all in a read-only environment.
        '''
>       path, env = testlib.temp_env(max_dbs=10)

tests/cursor_test.py:321: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test3g0n0ix8', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test3g0n0ix8: Operation not supported

tests/testlib.py:86: Error
______________________________ OpenTest.test_lock ______________________________

self = <env_test.OpenTest testMethod=test_lock>

    def test_lock(self):
        for flag in True, False:
>           path, env = testlib.temp_env(lock=flag)

tests/env_test.py:162: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testd8mmi_n2', max_dbs = 10, kwargs = {'lock': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testd8mmi_n2: Operation not supported

tests/testlib.py:86: Error
___________________________ OpenTest.test_map_async ____________________________

self = <env_test.OpenTest testMethod=test_map_async>

    def test_map_async(self):
        for flag in True, False:
>           path, env = testlib.temp_env(map_async=flag)

tests/env_test.py:174: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testlivsaddy', max_dbs = 10, kwargs = {'map_async': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testlivsaddy: Operation not supported

tests/testlib.py:86: Error
____________________________ OpenTest.test_max_dbs _____________________________

self = <env_test.OpenTest testMethod=test_max_dbs>

    def test_max_dbs(self):
        self.assertRaises(OverflowError,
            lambda: testlib.temp_env(max_dbs=-1))
        for val in 0, 10, 20:
>           _, env = testlib.temp_env(max_dbs=val)

tests/env_test.py:236: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testu5w2kf3w', max_dbs = 0, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testu5w2kf3w: Operation not supported

tests/testlib.py:86: Error
__________________________ OpenTest.test_max_readers ___________________________

self = <env_test.OpenTest testMethod=test_max_readers>

    def test_max_readers(self):
        self.assertRaises(lmdb.InvalidParameterError,
            lambda: testlib.temp_env(max_readers=0))
        for val in 123, 234:
>           _, env = testlib.temp_env(max_readers=val)

tests/env_test.py:229: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testhv4iy642', max_dbs = 10, kwargs = {'max_readers': 123}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testhv4iy642: Operation not supported

tests/testlib.py:86: Error
____________________________ OpenTest.test_meminit _____________________________

self = <env_test.OpenTest testMethod=test_meminit>

    def test_meminit(self):
        for flag in True, False:
>           path, env = testlib.temp_env(meminit=flag)

tests/env_test.py:222: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testpicv6f0l', max_dbs = 10, kwargs = {'meminit': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testpicv6f0l: Operation not supported

tests/testlib.py:86: Error
____________________________ OpenTest.test_metasync ____________________________

self = <env_test.OpenTest testMethod=test_metasync>

    def test_metasync(self):
        for flag in True, False:
>           path, env = testlib.temp_env(metasync=flag)

tests/env_test.py:157: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testvifd5tys', max_dbs = 10, kwargs = {'metasync': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testvifd5tys: Operation not supported

tests/testlib.py:86: Error
_______________________ OpenTest.test_mode_subdir_create _______________________

self = <env_test.OpenTest testMethod=test_mode_subdir_create>

    def test_mode_subdir_create(self):
        if sys.platform == 'win32':
            # Mode argument is ignored on Windows; see lmdb.h
            return
    
        oldmask = os.umask(0)
        try:
            for mode in OCT('777'), OCT('755'), OCT('700'):
                path = testlib.temp_dir(create=False)
>               env = lmdb.open(path, subdir=True, create=True, mode=mode)
E               lmdb.Error: /tmp/lmdb_test_82bndc_: Operation not supported

tests/env_test.py:186: Error
______________________ OpenTest.test_mode_subdir_nocreate ______________________

self = <env_test.OpenTest testMethod=test_mode_subdir_nocreate>

    def test_mode_subdir_nocreate(self):
        if sys.platform == 'win32':
            # Mode argument is ignored on Windows; see lmdb.h
            return
    
        oldmask = os.umask(0)
        try:
            for mode in OCT('777'), OCT('755'), OCT('700'):
                path = testlib.temp_dir()
>               env = lmdb.open(path, subdir=True, create=False, mode=mode)
E               lmdb.Error: /tmp/lmdb_testq1jbktc0: Operation not supported

tests/env_test.py:203: Error
____________________________ OpenTest.test_ok_path _____________________________

self = <env_test.OpenTest testMethod=test_ok_path>

    def test_ok_path(self):
>       path, env = testlib.temp_env()

tests/env_test.py:76: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testg9kf5ewh', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testg9kf5ewh: Operation not supported

tests/testlib.py:86: Error
___________________________ OpenTest.test_readahead ____________________________

self = <env_test.OpenTest testMethod=test_readahead>

    def test_readahead(self):
        for flag in True, False:
>           path, env = testlib.temp_env(readahead=flag)

tests/env_test.py:212: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test5jh06pcl', max_dbs = 10, kwargs = {'readahead': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test5jh06pcl: Operation not supported

tests/testlib.py:86: Error
_________________________ OpenTest.test_readonly_false _________________________

self = <env_test.OpenTest testMethod=test_readonly_false>

    def test_readonly_false(self):
>       path, env = testlib.temp_env(readonly=False)

tests/env_test.py:130: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testy7n82c7s', max_dbs = 10, kwargs = {'readonly': False}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testy7n82c7s: Operation not supported

tests/testlib.py:86: Error
______________________ OpenTest.test_readonly_true_exist _______________________

self = <env_test.OpenTest testMethod=test_readonly_true_exist>

    def test_readonly_true_exist(self):
>       path, env = testlib.temp_env()

tests/env_test.py:146: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test20d5gi2_', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test20d5gi2_: Operation not supported

tests/testlib.py:86: Error
_______________________ OpenTest.test_subdir_false_junk ________________________

self = <env_test.OpenTest testMethod=test_subdir_false_junk>

    def test_subdir_false_junk(self):
        path = testlib.temp_file()
        fp = open(path, 'wb')
        fp.write(B('A' * 8192))
        fp.close()
>       self.assertRaises(lmdb.InvalidError,
            lambda: lmdb.open(path, subdir=False))

tests/env_test.py:98: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

>   lambda: lmdb.open(path, subdir=False))
E   lmdb.Error: /tmp/lmdb_testvm2drd9t: Operation not supported

tests/env_test.py:99: Error
________________________ OpenTest.test_subdir_false_ok _________________________

self = <env_test.OpenTest testMethod=test_subdir_false_ok>

    def test_subdir_false_ok(self):
        path = testlib.temp_file(create=False)
>       _, env = testlib.temp_env(path, subdir=False)

tests/env_test.py:103: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testde1atnfr', max_dbs = 10, kwargs = {'subdir': False}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testde1atnfr: Operation not supported

tests/testlib.py:86: Error
____________________ OpenTest.test_subdir_true_exist_create ____________________

self = <env_test.OpenTest testMethod=test_subdir_true_exist_create>

    def test_subdir_true_exist_create(self):
>       path, env = testlib.temp_env()

tests/env_test.py:126: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testbec0iw3l', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testbec0iw3l: Operation not supported

tests/testlib.py:86: Error
___________________ OpenTest.test_subdir_true_exist_nocreate ___________________

self = <env_test.OpenTest testMethod=test_subdir_true_exist_nocreate>

    def test_subdir_true_exist_nocreate(self):
>       path, env = testlib.temp_env()

tests/env_test.py:122: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testybmsmaz4', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testybmsmaz4: Operation not supported

tests/testlib.py:86: Error
___________________ OpenTest.test_subdir_true_noexist_create ___________________

self = <env_test.OpenTest testMethod=test_subdir_true_noexist_create>

    def test_subdir_true_noexist_create(self):
        path = testlib.temp_dir(create=False)
>       path_, env = testlib.temp_env(path, subdir=True, create=True)

tests/env_test.py:117: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzzv0bpjf', max_dbs = 10
kwargs = {'create': True, 'subdir': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzzv0bpjf: Operation not supported

tests/testlib.py:86: Error
______________________________ OpenTest.test_sync ______________________________

self = <env_test.OpenTest testMethod=test_sync>

    def test_sync(self):
        for flag in True, False:
>           path, env = testlib.temp_env(sync=flag)

tests/env_test.py:169: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test5s0v0078', max_dbs = 10, kwargs = {'sync': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test5s0v0078: Operation not supported

tests/testlib.py:86: Error
___________________________ OpenTest.test_tiny_size ____________________________

self = <env_test.OpenTest testMethod=test_tiny_size>

    def test_tiny_size(self):
>       _, env = testlib.temp_env(map_size=10)

tests/env_test.py:87: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testf1_m4jq7', max_dbs = 10, kwargs = {'map_size': 10}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testf1_m4jq7: Operation not supported

tests/testlib.py:86: Error
____________________________ OpenTest.test_writemap ____________________________

self = <env_test.OpenTest testMethod=test_writemap>

    def test_writemap(self):
        for flag in True, False:
>           path, env = testlib.temp_env(writemap=flag)

tests/env_test.py:217: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4sl9mwkv', max_dbs = 10, kwargs = {'writemap': True}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4sl9mwkv: Operation not supported

tests/testlib.py:86: Error
_________________________ SetMapSizeTest.test_applied __________________________

self = <env_test.SetMapSizeTest testMethod=test_applied>

    def test_applied(self):
>       _, env = testlib.temp_env(map_size=PAGE_SIZE * 8)

tests/env_test.py:258: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testr4sc0tou', max_dbs = 10, kwargs = {'map_size': 32768}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testr4sc0tou: Operation not supported

tests/testlib.py:86: Error
_________________________ SetMapSizeTest.test_invalid __________________________

self = <env_test.SetMapSizeTest testMethod=test_invalid>

    def test_invalid(self):
>       _, env = testlib.temp_env()

tests/env_test.py:247: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testw3xl6ox8', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testw3xl6ox8: Operation not supported

tests/testlib.py:86: Error
_________________________ SetMapSizeTest.test_negative _________________________

self = <env_test.SetMapSizeTest testMethod=test_negative>

    def test_negative(self):
>       _, env = testlib.temp_env()

tests/env_test.py:253: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testizpp1pu3', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testizpp1pu3: Operation not supported

tests/testlib.py:86: Error
_____________________________ CloseTest.test_close _____________________________

self = <env_test.CloseTest testMethod=test_close>

    def test_close(self):
>       _, env = testlib.temp_env()

tests/env_test.py:270: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_tests7wqpo3n', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_tests7wqpo3n: Operation not supported

tests/testlib.py:86: Error
________________________ ContextManagerTest.test_crash _________________________

self = <env_test.ContextManagerTest testMethod=test_crash>

    def test_crash(self):
>       path, env = testlib.temp_env()

tests/env_test.py:307: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test0e3m25ry', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test0e3m25ry: Operation not supported

tests/testlib.py:86: Error
__________________________ ContextManagerTest.test_ok __________________________

self = <env_test.ContextManagerTest testMethod=test_ok>

    def test_ok(self):
>       path, env = testlib.temp_env()

tests/env_test.py:299: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testmqe5dkji', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testmqe5dkji: Operation not supported

tests/testlib.py:86: Error
__________________________ InfoMethodsTest.test_flags __________________________

self = <env_test.InfoMethodsTest testMethod=test_flags>

    def test_flags(self):
>       _, env = testlib.temp_env()

tests/env_test.py:370: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test__bd43m8', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test__bd43m8: Operation not supported

tests/testlib.py:86: Error
__________________________ InfoMethodsTest.test_info ___________________________

self = <env_test.InfoMethodsTest testMethod=test_info>

    def test_info(self):
>       _, env = testlib.temp_env()

tests/env_test.py:351: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testm2jnuz2b', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testm2jnuz2b: Operation not supported

tests/testlib.py:86: Error
______________________ InfoMethodsTest.test_max_key_size _______________________

self = <env_test.InfoMethodsTest testMethod=test_max_key_size>

    def test_max_key_size(self):
>       _, env = testlib.temp_env()

tests/env_test.py:381: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testidedscfx', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testidedscfx: Operation not supported

tests/testlib.py:86: Error
_______________________ InfoMethodsTest.test_max_readers _______________________

self = <env_test.InfoMethodsTest testMethod=test_max_readers>

    def test_max_readers(self):
>       _, env = testlib.temp_env()

tests/env_test.py:391: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testr55nk4_e', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testr55nk4_e: Operation not supported

tests/testlib.py:86: Error
__________________________ InfoMethodsTest.test_path ___________________________

self = <env_test.InfoMethodsTest testMethod=test_path>

    def test_path(self):
>       path, env = testlib.temp_env()

tests/env_test.py:323: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test7uric36l', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test7uric36l: Operation not supported

tests/testlib.py:86: Error
_________________________ InfoMethodsTest.test_readers _________________________

self = <env_test.InfoMethodsTest testMethod=test_readers>

    def test_readers(self):
>       _, env = testlib.temp_env(max_spare_txns=0)

tests/env_test.py:401: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testxmgqp105', max_dbs = 10, kwargs = {'max_spare_txns': 0}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testxmgqp105: Operation not supported

tests/testlib.py:86: Error
__________________________ InfoMethodsTest.test_stat ___________________________

self = <env_test.InfoMethodsTest testMethod=test_stat>

    def test_stat(self):
>       _, env = testlib.temp_env()

tests/env_test.py:332: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testuq4ob45q', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testuq4ob45q: Operation not supported

tests/testlib.py:86: Error
__________________________ OtherMethodsTest.test_copy __________________________

self = <env_test.OtherMethodsTest testMethod=test_copy>

    def test_copy(self):
>       _, env = testlib.temp_env()

tests/env_test.py:421: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test57mpimc8', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test57mpimc8: Operation not supported

tests/testlib.py:86: Error
______________________ OtherMethodsTest.test_copy_compact ______________________

self = <env_test.OtherMethodsTest testMethod=test_copy_compact>

    def test_copy_compact(self):
>       _, env = testlib.temp_env()

tests/env_test.py:445: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test69qo66_5', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test69qo66_5: Operation not supported

tests/testlib.py:86: Error
_________________________ OtherMethodsTest.test_copyfd _________________________

self = <env_test.OtherMethodsTest testMethod=test_copyfd>

    def test_copyfd(self):
>       path, env = testlib.temp_env()

tests/env_test.py:530: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test2eyo_mmh', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test2eyo_mmh: Operation not supported

tests/testlib.py:86: Error
_____________________ OtherMethodsTest.test_copyfd_compact _____________________

self = <env_test.OtherMethodsTest testMethod=test_copyfd_compact>

    def test_copyfd_compact(self):
>       path, env = testlib.temp_env()

tests/env_test.py:486: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testlbbrl3nx', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testlbbrl3nx: Operation not supported

tests/testlib.py:86: Error
______________________ OtherMethodsTest.test_reader_check ______________________

self = <env_test.OtherMethodsTest testMethod=test_reader_check>

    def test_reader_check(self):
        if sys.platform == 'win32':
            # Stale writers are cleared automatically on Windows, see lmdb.h
            return
    
>       path, env = testlib.temp_env(max_spare_txns=0)

tests/env_test.py:574: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testc5l6vxx3', max_dbs = 10, kwargs = {'max_spare_txns': 0}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testc5l6vxx3: Operation not supported

tests/testlib.py:86: Error
__________________________ OtherMethodsTest.test_sync __________________________

self = <env_test.OtherMethodsTest testMethod=test_sync>

    def test_sync(self):
>       _, env = testlib.temp_env()

tests/env_test.py:554: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testlbrnc8ca', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testlbrnc8ca: Operation not supported

tests/testlib.py:86: Error
_________________________ BeginTest.test_begin_closed __________________________

self = <env_test.BeginTest testMethod=test_begin_closed>

    def test_begin_closed(self):
>       _, env = testlib.temp_env()

tests/env_test.py:610: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testlm8_y7cd', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testlm8_y7cd: Operation not supported

tests/testlib.py:86: Error
________________________ BeginTest.test_begin_readonly _________________________

self = <env_test.BeginTest testMethod=test_begin_readonly>

    def test_begin_readonly(self):
>       _, env = testlib.temp_env()

tests/env_test.py:616: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test0lahep4i', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test0lahep4i: Operation not supported

tests/testlib.py:86: Error
__________________________ BeginTest.test_begin_write __________________________

self = <env_test.BeginTest testMethod=test_begin_write>

    def test_begin_write(self):
>       _, env = testlib.temp_env()

tests/env_test.py:624: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzx8x4kv5', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzx8x4kv5: Operation not supported

tests/testlib.py:86: Error
____________________________ BeginTest.test_bind_db ____________________________

self = <env_test.BeginTest testMethod=test_bind_db>

    def test_bind_db(self):
>       _, env = testlib.temp_env()

tests/env_test.py:631: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test76ts3ncq', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test76ts3ncq: Operation not supported

tests/testlib.py:86: Error
____________________________ BeginTest.test_buffers ____________________________

self = <env_test.BeginTest testMethod=test_buffers>

    def test_buffers(self):
>       _, env = testlib.temp_env()

tests/env_test.py:676: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testtwpto6gp', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testtwpto6gp: Operation not supported

tests/testlib.py:86: Error
____________________________ BeginTest.test_parent _____________________________

self = <env_test.BeginTest testMethod=test_parent>

    def test_parent(self):
>       _, env = testlib.temp_env()

tests/env_test.py:656: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testx2omgbm2', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testx2omgbm2: Operation not supported

tests/testlib.py:86: Error
________________________ BeginTest.test_parent_readonly ________________________

self = <env_test.BeginTest testMethod=test_parent_readonly>

    def test_parent_readonly(self):
>       _, env = testlib.temp_env()

tests/env_test.py:649: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testf73h62__', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testf73h62__: Operation not supported

tests/testlib.py:86: Error
____________________________ OpenDbTest.test_flags _____________________________

self = <env_test.OpenDbTest testMethod=test_flags>

    def test_flags(self):
>       path, env = testlib.temp_env()

tests/env_test.py:765: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testgw53bipy', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testgw53bipy: Operation not supported

tests/testlib.py:86: Error
_____________________________ OpenDbTest.test_main _____________________________

self = <env_test.OpenDbTest testMethod=test_main>

    def test_main(self):
>       _, env = testlib.temp_env()

tests/env_test.py:698: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testvsoq0_hg', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testvsoq0_hg: Operation not supported

tests/testlib.py:86: Error
______________________ OpenDbTest.test_readonly_env_main _______________________

self = <env_test.OpenDbTest testMethod=test_readonly_env_main>

    def test_readonly_env_main(self):
>       path, env = testlib.temp_env()

tests/env_test.py:788: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testm4bhkbji', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testm4bhkbji: Operation not supported

tests/testlib.py:86: Error
_______________________ OpenDbTest.test_readonly_env_sub _______________________

self = <env_test.OpenDbTest testMethod=test_readonly_env_sub>

    def test_readonly_env_sub(self):
        # https://github.com/dw/py-lmdb/issues/109
>       path, env = testlib.temp_env()

tests/env_test.py:814: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testsiiiiac3', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testsiiiiac3: Operation not supported

tests/testlib.py:86: Error
____________________ OpenDbTest.test_readonly_env_sub_eperm ____________________

self = <env_test.OpenDbTest testMethod=test_readonly_env_sub_eperm>

    def test_readonly_env_sub_eperm(self):
        # https://github.com/dw/py-lmdb/issues/109
>       path, env = testlib.temp_env()

tests/env_test.py:805: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testmixbtox3', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testmixbtox3: Operation not supported

tests/testlib.py:86: Error
___________________ OpenDbTest.test_readonly_env_sub_noexist ___________________

self = <env_test.OpenDbTest testMethod=test_readonly_env_sub_noexist>

    def test_readonly_env_sub_noexist(self):
        # https://github.com/dw/py-lmdb/issues/109
>       path, env = testlib.temp_env()

tests/env_test.py:796: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test9m5n5vx_', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test9m5n5vx_: Operation not supported

tests/testlib.py:86: Error
____________________________ OpenDbTest.test_reopen ____________________________

self = <env_test.OpenDbTest testMethod=test_reopen>

    def test_reopen(self):
>       path, env = testlib.temp_env()

tests/env_test.py:750: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testjm3jw4i9', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testjm3jw4i9: Operation not supported

tests/testlib.py:86: Error
__________________________ OpenDbTest.test_sub_notxn ___________________________

self = <env_test.OpenDbTest testMethod=test_sub_notxn>

    def test_sub_notxn(self):
>       _, env = testlib.temp_env()

tests/env_test.py:717: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test36idohhd', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test36idohhd: Operation not supported

tests/testlib.py:86: Error
__________________________ OpenDbTest.test_sub_rotxn ___________________________

self = <env_test.OpenDbTest testMethod=test_sub_rotxn>

    def test_sub_rotxn(self):
>       _, env = testlib.temp_env()

tests/env_test.py:729: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4a4_u_ow', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4a4_u_ow: Operation not supported

tests/testlib.py:86: Error
___________________________ OpenDbTest.test_sub_txn ____________________________

self = <env_test.OpenDbTest testMethod=test_sub_txn>

    def test_sub_txn(self):
>       _, env = testlib.temp_env()

tests/env_test.py:735: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testdy3drsyn', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testdy3drsyn: Operation not supported

tests/testlib.py:86: Error
___________________________ OpenDbTest.test_unicode ____________________________

self = <env_test.OpenDbTest testMethod=test_unicode>

    def test_unicode(self):
>       _, env = testlib.temp_env()

tests/env_test.py:711: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testolppg8_e', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testolppg8_e: Operation not supported

tests/testlib.py:86: Error
____________________________ SpareTxnTest.test_none ____________________________

self = <env_test.SpareTxnTest testMethod=test_none>

    def test_none(self):
>       _, env = testlib.temp_env(max_spare_txns=0)

tests/env_test.py:830: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test6dx0mom8', max_dbs = 10, kwargs = {'max_spare_txns': 0}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test6dx0mom8: Operation not supported

tests/testlib.py:86: Error
____________________________ SpareTxnTest.test_one _____________________________

self = <env_test.SpareTxnTest testMethod=test_one>

    def test_one(self):
>       _, env = testlib.temp_env(max_spare_txns=1)

tests/env_test.py:848: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test51z104wq', max_dbs = 10, kwargs = {'max_spare_txns': 1}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test51z104wq: Operation not supported

tests/testlib.py:86: Error
____________________ LeakTest.test_open_close_does_not_leak ____________________

self = <env_test.LeakTest testMethod=test_open_close_does_not_leak>

    def test_open_close_does_not_leak(self):
        temp_dir = testlib.temp_dir()
>       env = lmdb.open(temp_dir)
E       lmdb.Error: /tmp/lmdb_testaasuh1h2: Operation not supported

tests/env_test.py:888: Error
____________________ LeakTest.test_open_unref_does_not_leak ____________________

self = <env_test.LeakTest testMethod=test_open_unref_does_not_leak>

    def test_open_unref_does_not_leak(self):
        temp_dir = testlib.temp_dir()
>       env = lmdb.open(temp_dir)
E       lmdb.Error: /tmp/lmdb_testh3144heq: Operation not supported

tests/env_test.py:880: Error
_________________ LeakTest.test_weakref_callback_invoked_once __________________

self = <env_test.LeakTest testMethod=test_weakref_callback_invoked_once>

    def test_weakref_callback_invoked_once(self):
        temp_dir = testlib.temp_dir()
>       env = lmdb.open(temp_dir)
E       lmdb.Error: /tmp/lmdb_test6inooye7: Operation not supported

tests/env_test.py:897: Error
_________________ GetMultiTestNoDupsortNoDupfixed.testGetMulti _________________

self = <getmulti_test.GetMultiTestNoDupsortNoDupfixed testMethod=testGetMulti>
dupsort = False, dupfixed = False

    def setUp(self, dupsort=False, dupfixed=False):
>       super(GetMultiTestNoDupsortNoDupfixed, self).setUp(dupsort=dupsort, dupfixed=dupfixed)

tests/getmulti_test.py:36: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/getmulti_test.py:16: in setUp
    self.path, self.env = testlib.temp_env(max_dbs=1)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testh2soktlh', max_dbs = 1, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testh2soktlh: Operation not supported

tests/testlib.py:86: Error
__________________ GetMultiTestDupsortNoDupfixed.testGetMulti __________________

self = <getmulti_test.GetMultiTestDupsortNoDupfixed testMethod=testGetMulti>
dupsort = True, dupfixed = False

    def setUp(self, dupsort=True, dupfixed=False):
>       super(GetMultiTestDupsortNoDupfixed, self).setUp(dupsort=dupsort, dupfixed=dupfixed)

tests/getmulti_test.py:46: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/getmulti_test.py:16: in setUp
    self.path, self.env = testlib.temp_env(max_dbs=1)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzvpeqfz9', max_dbs = 1, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzvpeqfz9: Operation not supported

tests/testlib.py:86: Error
___________________ GetMultiTestDupsortDupfixed.testGetMulti ___________________

self = <getmulti_test.GetMultiTestDupsortDupfixed testMethod=testGetMulti>
dupsort = True, dupfixed = True

    def setUp(self, dupsort=True, dupfixed=True):
>       super(GetMultiTestDupsortDupfixed, self).setUp(dupsort=dupsort, dupfixed=dupfixed)

tests/getmulti_test.py:56: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/getmulti_test.py:16: in setUp
    self.path, self.env = testlib.temp_env(max_dbs=1)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testmruodq4n', max_dbs = 1, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testmruodq4n: Operation not supported

tests/testlib.py:86: Error
_______________ GetMultiTestDupsortDupfixedKeyfixed.testGetMulti _______________

self = <getmulti_test.GetMultiTestDupsortDupfixedKeyfixed testMethod=testGetMulti>
dupsort = True, dupfixed = True

    def setUp(self, dupsort=True, dupfixed=True):
>       super(GetMultiTestDupsortDupfixedKeyfixed, self).setUp(dupsort=dupsort, dupfixed=dupfixed)

tests/getmulti_test.py:65: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/getmulti_test.py:16: in setUp
    self.path, self.env = testlib.temp_env(max_dbs=1)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_tests047w8p3', max_dbs = 1, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_tests047w8p3: Operation not supported

tests/testlib.py:86: Error
___________________ IterationTest.testFromExistentKeySetKey ____________________

self = <iteration_test.IterationTest testMethod=testFromExistentKeySetKey>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_teston2wtgp7', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_teston2wtgp7: Operation not supported

tests/testlib.py:86: Error
__________________ IterationTest.testFromExistentKeySetRange ___________________

self = <iteration_test.IterationTest testMethod=testFromExistentKeySetRange>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test_xs5alfa', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test_xs5alfa: Operation not supported

tests/testlib.py:86: Error
________________________ IterationTest.testFromLastKey _________________________

self = <iteration_test.IterationTest testMethod=testFromLastKey>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test7ohcmsv2', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test7ohcmsv2: Operation not supported

tests/testlib.py:86: Error
_________________ IterationTest.testFromNonExistentKeyPastEnd __________________

self = <iteration_test.IterationTest testMethod=testFromNonExistentKeyPastEnd>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testvpj40fc2', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testvpj40fc2: Operation not supported

tests/testlib.py:86: Error
_________________ IterationTest.testFromNonExistentKeySetRange _________________

self = <iteration_test.IterationTest testMethod=testFromNonExistentKeySetRange>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testn_i_u_dm', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testn_i_u_dm: Operation not supported

tests/testlib.py:86: Error
_________________________ IterationTest.testFromStart __________________________

self = <iteration_test.IterationTest testMethod=testFromStart>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test8kqqbwd8', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test8kqqbwd8: Operation not supported

tests/testlib.py:86: Error
___________________ IterationTest.testFromStartWithIternext ____________________

self = <iteration_test.IterationTest testMethod=testFromStartWithIternext>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test73aqgnlg', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test73aqgnlg: Operation not supported

tests/testlib.py:86: Error
_____________________ IterationTest.testFromStartWithNext ______________________

self = <iteration_test.IterationTest testMethod=testFromStartWithNext>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testl8gzu9ir', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testl8gzu9ir: Operation not supported

tests/testlib.py:86: Error
______________ ReverseIterationTest.testFromExistentKeySetKeyRev _______________

self = <iteration_test.ReverseIterationTest testMethod=testFromExistentKeySetKeyRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testa6xnae2g', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testa6xnae2g: Operation not supported

tests/testlib.py:86: Error
_____________ ReverseIterationTest.testFromExistentKeySetRangeRev ______________

self = <iteration_test.ReverseIterationTest testMethod=testFromExistentKeySetRangeRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test0nk4e0b4', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test0nk4e0b4: Operation not supported

tests/testlib.py:86: Error
___________________ ReverseIterationTest.testFromLastKeyRev ____________________

self = <iteration_test.ReverseIterationTest testMethod=testFromLastKeyRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testcy2ohjp7', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testcy2ohjp7: Operation not supported

tests/testlib.py:86: Error
_______________ ReverseIterationTest.testFromLastKeyWithPrevRev ________________

self = <iteration_test.ReverseIterationTest testMethod=testFromLastKeyWithPrevRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testdwe_xh40', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testdwe_xh40: Operation not supported

tests/testlib.py:86: Error
____________ ReverseIterationTest.testFromNonExistentKeyPastEndRev _____________

self = <iteration_test.ReverseIterationTest testMethod=testFromNonExistentKeyPastEndRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testf50le4qb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testf50le4qb: Operation not supported

tests/testlib.py:86: Error
____________ ReverseIterationTest.testFromNonExistentKeySetRangeRev ____________

self = <iteration_test.ReverseIterationTest testMethod=testFromNonExistentKeySetRangeRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testslx3eke6', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testslx3eke6: Operation not supported

tests/testlib.py:86: Error
____________________ ReverseIterationTest.testFromStartRev _____________________

self = <iteration_test.ReverseIterationTest testMethod=testFromStartRev>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testg13zt9ux', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testg13zt9ux: Operation not supported

tests/testlib.py:86: Error
_________________ SeekIterationTest.testDeleteDuringIteration __________________

self = <iteration_test.SeekIterationTest testMethod=testDeleteDuringIteration>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test_8w0kl40', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test_8w0kl40: Operation not supported

tests/testlib.py:86: Error
__________________ SeekIterationTest.testForwardIterationSeek __________________

self = <iteration_test.SeekIterationTest testMethod=testForwardIterationSeek>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test40plt62j', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test40plt62j: Operation not supported

tests/testlib.py:86: Error
___________________ SeekIterationTest.testPutDuringIteration ___________________

self = <iteration_test.SeekIterationTest testMethod=testPutDuringIteration>

    def setUp(self):
>       self.path, self.env = testlib.temp_env()  # creates 10 databases

tests/iteration_test.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test63yruv3j', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test63yruv3j: Operation not supported

tests/testlib.py:86: Error
____________________________ ToolTest.test_cmd_get _____________________________

self = <tool_test.ToolTest testMethod=test_cmd_get>

    def test_cmd_get(self):
>       frompath, env = testlib.temp_env()

tests/tool_test.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test7iol0751', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test7iol0751: Operation not supported

tests/testlib.py:86: Error
__________________________ ToolTest.test_cmd_rewrite ___________________________

self = <tool_test.ToolTest testMethod=test_cmd_rewrite>

    def test_cmd_rewrite(self):
>       frompath, env = testlib.temp_env()

tests/tool_test.py:50: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testz8rjq1dl', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testz8rjq1dl: Operation not supported

tests/testlib.py:86: Error
__________________________ InitTest.test_begin_write ___________________________

self = <txn_test.InitTest testMethod=test_begin_write>

    def test_begin_write(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:62: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testbyh7h_3i', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testbyh7h_3i: Operation not supported

tests/testlib.py:86: Error
____________________________ InitTest.test_bind_db _____________________________

self = <txn_test.InitTest testMethod=test_bind_db>

    def test_bind_db(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:69: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testgssmqb80', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testgssmqb80: Operation not supported

tests/testlib.py:86: Error
________________________ InitTest.test_bind_db_methods _________________________

self = <txn_test.InitTest testMethod=test_bind_db_methods>

    def test_bind_db_methods(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:86: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4orbjbym', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4orbjbym: Operation not supported

tests/testlib.py:86: Error
____________________________ InitTest.test_buffers _____________________________

self = <txn_test.InitTest testMethod=test_buffers>

    def test_buffers(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:127: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testkb_uapps', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testkb_uapps: Operation not supported

tests/testlib.py:86: Error
_____________________________ InitTest.test_closed _____________________________

self = <txn_test.InitTest testMethod=test_closed>

    def test_closed(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:48: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4c6zh8nk', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4c6zh8nk: Operation not supported

tests/testlib.py:86: Error
_____________________________ InitTest.test_parent _____________________________

self = <txn_test.InitTest testMethod=test_parent>

    def test_parent(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:107: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testu45zg5yo', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testu45zg5yo: Operation not supported

tests/testlib.py:86: Error
________________________ InitTest.test_parent_readonly _________________________

self = <txn_test.InitTest testMethod=test_parent_readonly>

    def test_parent_readonly(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:100: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testaibgw5zo', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testaibgw5zo: Operation not supported

tests/testlib.py:86: Error
____________________________ InitTest.test_readonly ____________________________

self = <txn_test.InitTest testMethod=test_readonly>

    def test_readonly(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:54: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testpmwyisuo', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testpmwyisuo: Operation not supported

tests/testlib.py:86: Error
________________________ ContextManagerTest.test_crash _________________________

self = <txn_test.ContextManagerTest testMethod=test_crash>

    def test_crash(self):
>       path, env = testlib.temp_env()

tests/txn_test.py:160: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testda1s7k0t', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testda1s7k0t: Operation not supported

tests/testlib.py:86: Error
__________________________ ContextManagerTest.test_ok __________________________

self = <txn_test.ContextManagerTest testMethod=test_ok>

    def test_ok(self):
>       path, env = testlib.temp_env()

tests/txn_test.py:149: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test8d5gppkj', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test8d5gppkj: Operation not supported

tests/testlib.py:86: Error
___________________________ IdTest.test_invalid_txn ____________________________

self = <txn_test.IdTest testMethod=test_invalid_txn>

    def test_invalid_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:197: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test972qitl7', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test972qitl7: Operation not supported

tests/testlib.py:86: Error
_______________________ IdTest.test_readonly_after_write _______________________

self = <txn_test.IdTest testMethod=test_readonly_after_write>

    def test_readonly_after_write(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:190: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testiaeg76fy', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testiaeg76fy: Operation not supported

tests/testlib.py:86: Error
___________________________ IdTest.test_readonly_new ___________________________

self = <txn_test.IdTest testMethod=test_readonly_new>

    def test_readonly_new(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:180: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test3pke3deq', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test3pke3deq: Operation not supported

tests/testlib.py:86: Error
____________________________ IdTest.test_write_new _____________________________

self = <txn_test.IdTest testMethod=test_write_new>

    def test_write_new(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:185: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test9u5qe23l', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test9u5qe23l: Operation not supported

tests/testlib.py:86: Error
______________________________ StatTest.test_stat ______________________________

self = <txn_test.StatTest testMethod=test_stat>

    def test_stat(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:208: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzio3pn3j', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzio3pn3j: Operation not supported

tests/testlib.py:86: Error
_____________________________ DropTest.test_delete _____________________________

self = <txn_test.DropTest testMethod=test_delete>

    def test_delete(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:256: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testme3vkygx', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testme3vkygx: Operation not supported

tests/testlib.py:86: Error
_________________________ DropTest.test_double_delete __________________________

self = <txn_test.DropTest testMethod=test_double_delete>

    def test_double_delete(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:267: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testq3gqusef', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testq3gqusef: Operation not supported

tests/testlib.py:86: Error
_____________________________ DropTest.test_empty ______________________________

self = <txn_test.DropTest testMethod=test_empty>

    def test_empty(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:245: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testsiaaf4wt', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testsiaaf4wt: Operation not supported

tests/testlib.py:86: Error
___________________________ CommitTest.test_bad_env ____________________________

self = <txn_test.CommitTest testMethod=test_bad_env>

    def test_bad_env(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:302: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test_d_95ew4', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test_d_95ew4: Operation not supported

tests/testlib.py:86: Error
___________________________ CommitTest.test_bad_txn ____________________________

self = <txn_test.CommitTest testMethod=test_bad_txn>

    def test_bad_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:295: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testklony0n0', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testklony0n0: Operation not supported

tests/testlib.py:86: Error
__________________________ CommitTest.test_commit_ro ___________________________

self = <txn_test.CommitTest testMethod=test_commit_ro>

    def test_commit_ro(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:309: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testdu72m9m9', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testdu72m9m9: Operation not supported

tests/testlib.py:86: Error
__________________________ CommitTest.test_commit_rw ___________________________

self = <txn_test.CommitTest testMethod=test_commit_rw>

    def test_commit_rw(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:316: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testmouysg9m', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testmouysg9m: Operation not supported

tests/testlib.py:86: Error
___________________________ AbortTest.test_abort_ro ____________________________

self = <txn_test.AbortTest testMethod=test_abort_ro>

    def test_abort_ro(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:332: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testcras0aq3', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testcras0aq3: Operation not supported

tests/testlib.py:86: Error
___________________________ AbortTest.test_abort_rw ____________________________

self = <txn_test.AbortTest testMethod=test_abort_rw>

    def test_abort_rw(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:343: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testymakcztb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testymakcztb: Operation not supported

tests/testlib.py:86: Error
_____________________________ GetTest.test_bad_env _____________________________

self = <txn_test.GetTest testMethod=test_bad_env>

    def test_bad_env(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:363: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testyvycw8mn', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testyvycw8mn: Operation not supported

tests/testlib.py:86: Error
_____________________________ GetTest.test_bad_txn _____________________________

self = <txn_test.GetTest testMethod=test_bad_txn>

    def test_bad_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:356: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testo_fhk2bb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testo_fhk2bb: Operation not supported

tests/testlib.py:86: Error
___________________________ GetTest.test_buffers_no ____________________________

self = <txn_test.GetTest testMethod=test_buffers_no>

    def test_buffers_no(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:403: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testnoqvf6sw', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testnoqvf6sw: Operation not supported

tests/testlib.py:86: Error
___________________________ GetTest.test_buffers_yes ___________________________

self = <txn_test.GetTest testMethod=test_buffers_yes>

    def test_buffers_yes(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:409: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testhvp14lwv', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testhvp14lwv: Operation not supported

tests/testlib.py:86: Error
_______________________________ GetTest.test_db ________________________________

self = <txn_test.GetTest testMethod=test_db>

    def test_db(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:382: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testutvnbrs9', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testutvnbrs9: Operation not supported

tests/testlib.py:86: Error
____________________________ GetTest.test_dupfixed _____________________________

self = <txn_test.GetTest testMethod=test_dupfixed>

    def test_dupfixed(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:440: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testi7mdqpk0', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testi7mdqpk0: Operation not supported

tests/testlib.py:86: Error
_____________________________ GetTest.test_dupsort _____________________________

self = <txn_test.GetTest testMethod=test_dupsort>

    def test_dupsort(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:415: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test3f5tj06m', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test3f5tj06m: Operation not supported

tests/testlib.py:86: Error
____________________________ GetTest.test_empty_key ____________________________

self = <txn_test.GetTest testMethod=test_empty_key>

    def test_empty_key(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:376: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test_h71yd3j', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test_h71yd3j: Operation not supported

tests/testlib.py:86: Error
___________________________ GetTest.test_integerdup ____________________________

self = <txn_test.GetTest testMethod=test_integerdup>

    def test_integerdup(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:432: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testm7eesc6m', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testm7eesc6m: Operation not supported

tests/testlib.py:86: Error
___________________________ GetTest.test_integerkey ____________________________

self = <txn_test.GetTest testMethod=test_integerkey>

    def test_integerkey(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:423: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testj9aqe6ar', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testj9aqe6ar: Operation not supported

tests/testlib.py:86: Error
_____________________________ GetTest.test_missing _____________________________

self = <txn_test.GetTest testMethod=test_missing>

    def test_missing(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:370: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testev83y582', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testev83y582: Operation not supported

tests/testlib.py:86: Error
_____________________________ PutTest.test_bad_env _____________________________

self = <txn_test.PutTest testMethod=test_bad_env>

    def test_bad_env(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:460: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testnv2wo3g5', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testnv2wo3g5: Operation not supported

tests/testlib.py:86: Error
_____________________________ PutTest.test_bad_txn _____________________________

self = <txn_test.PutTest testMethod=test_bad_txn>

    def test_bad_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:453: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testkfgdrhzb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testkfgdrhzb: Operation not supported

tests/testlib.py:86: Error
_______________________ PutTest.test_dupdata_no_dupsort ________________________

self = <txn_test.PutTest testMethod=test_dupdata_no_dupsort>

    def test_dupdata_no_dupsort(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:482: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test9m_bzs9z', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test9m_bzs9z: Operation not supported

tests/testlib.py:86: Error
_____________________________ PutTest.test_dupsort _____________________________

self = <txn_test.PutTest testMethod=test_dupsort>

    def test_dupsort(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:479: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test1b88ntex', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test1b88ntex: Operation not supported

tests/testlib.py:86: Error
_________________________ PutTest.test_empty_key_value _________________________

self = <txn_test.PutTest testMethod=test_empty_key_value>

    def test_empty_key_value(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:473: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testqt0gj46q', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testqt0gj46q: Operation not supported

tests/testlib.py:86: Error
_____________________________ PutTest.test_ro_txn ______________________________

self = <txn_test.PutTest testMethod=test_ro_txn>

    def test_ro_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:467: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testkw2zoq57', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testkw2zoq57: Operation not supported

tests/testlib.py:86: Error
___________________________ ReplaceTest.test_bad_env ___________________________

self = <txn_test.ReplaceTest testMethod=test_bad_env>

    def test_bad_env(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:501: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testzfnsie28', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testzfnsie28: Operation not supported

tests/testlib.py:86: Error
___________________________ ReplaceTest.test_bad_txn ___________________________

self = <txn_test.ReplaceTest testMethod=test_bad_txn>

    def test_bad_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:494: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test4hlwo43x', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test4hlwo43x: Operation not supported

tests/testlib.py:86: Error
_____________________ ReplaceTest.test_dupdata_no_dupsort ______________________

self = <txn_test.ReplaceTest testMethod=test_dupdata_no_dupsort>

    def test_dupdata_no_dupsort(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:542: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testj35x730l', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testj35x730l: Operation not supported

tests/testlib.py:86: Error
______________________ ReplaceTest.test_dupsort_del_none _______________________

self = <txn_test.ReplaceTest testMethod=test_dupsort_del_none>

    def test_dupsort_del_none(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:531: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testl485vcrd', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testl485vcrd: Operation not supported

tests/testlib.py:86: Error
_______________________ ReplaceTest.test_dupsort_noexist _______________________

self = <txn_test.ReplaceTest testMethod=test_dupsort_noexist>

    def test_dupsort_noexist(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:520: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test6p_bc_yz', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test6p_bc_yz: Operation not supported

tests/testlib.py:86: Error
_______________________ ReplaceTest.test_empty_key_value _______________________

self = <txn_test.ReplaceTest testMethod=test_empty_key_value>

    def test_empty_key_value(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:514: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_testx7jxyre3', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_testx7jxyre3: Operation not supported

tests/testlib.py:86: Error
___________________________ ReplaceTest.test_ro_txn ____________________________

self = <txn_test.ReplaceTest testMethod=test_ro_txn>

    def test_ro_txn(self):
>       _, env = testlib.temp_env()

tests/txn_test.py:508: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

path = '/tmp/lmdb_test04ifqqhb', max_dbs = 10, kwargs = {}

    def temp_env(path=None, max_dbs=10, **kwargs):
        if not path:
            path = temp_dir()
>       env = lmdb.open(path, max_dbs=max_dbs, **kwargs)
E       lmdb.Error: /tmp/lmdb_test04ifqqhb: Operation not supported

tests/testlib.py:86: Error
___________________________ LeakTest.test_open_close ___________________________

self = <txn_test.LeakTest testMethod=test_open_close>

    def test_open_close(self):
        temp_dir = testlib.temp_dir()
>       env = lmdb.open(temp_dir)
E       lmdb.Error: /tmp/lmdb_testaaakt8_a: Operation not supported

tests/txn_test.py:555: Error
=========================== short test summary info ============================
FAILED tests/crash_test.py::CrashTest::testCloseWithTxn - lmdb.Error: /tmp/lm...
FAILED tests/crash_test.py::CrashTest::testDbCloseActiveIter - lmdb.Error: /t...
FAILED tests/crash_test.py::CrashTest::testDoubleClose - lmdb.Error: /tmp/lmd...
FAILED tests/crash_test.py::CrashTest::testOldCrash - lmdb.Error: /tmp/lmdb_t...
FAILED tests/crash_test.py::CrashTest::testTxnCloseActiveIter - lmdb.Error: /...
FAILED tests/crash_test.py::IteratorTest::testEmpty - lmdb.Error: /tmp/lmdb_t...
FAILED tests/crash_test.py::IteratorTest::testFilled - lmdb.Error: /tmp/lmdb_...
FAILED tests/crash_test.py::IteratorTest::testFilledSkipEof - lmdb.Error: /tm...
FAILED tests/crash_test.py::IteratorTest::testFilledSkipForward - lmdb.Error:...
FAILED tests/crash_test.py::IteratorTest::testFilledSkipReverse - lmdb.Error:...
FAILED tests/crash_test.py::BigReverseTest::test_big_reverse - lmdb.Error: /t...
FAILED tests/crash_test.py::MultiCursorDeleteTest::test1 - lmdb.Error: /tmp/l...
FAILED tests/crash_test.py::MultiCursorDeleteTest::test_monster - lmdb.Error:...
FAILED tests/crash_test.py::TxnFullTest::test_17bf75b12eb94d9903cd62329048b146d5313bad
FAILED tests/crash_test.py::EmptyIterTest::test_python3_iternext_segfault - l...
FAILED tests/crash_test.py::MultiputTest::test_multiput_segfault - lmdb.Error...
FAILED tests/crash_test.py::InvalidArgTest::test_duplicate_arg - lmdb.Error: ...
FAILED tests/crash_test.py::BadCursorTest::test_cursor_open_failure - lmdb.Er...
FAILED tests/crash_test.py::MapResizeTest::test_opendb_resize - lmdb.Error: /...
FAILED tests/cursor_test.py::ContextManagerTest::test_crash - lmdb.Error: /tm...
FAILED tests/cursor_test.py::ContextManagerTest::test_ok - lmdb.Error: /tmp/l...
FAILED tests/cursor_test.py::CursorTest::testCount - lmdb.Error: /tmp/lmdb_te...
FAILED tests/cursor_test.py::CursorTest::testDeleteEmpty - lmdb.Error: /tmp/l...
FAILED tests/cursor_test.py::CursorTest::testDeleteFirst - lmdb.Error: /tmp/l...
FAILED tests/cursor_test.py::CursorTest::testDeleteLast - lmdb.Error: /tmp/lm...
FAILED tests/cursor_test.py::CursorTest::testFirstFilled - lmdb.Error: /tmp/l...
FAILED tests/cursor_test.py::CursorTest::testFirstLastEmpty - lmdb.Error: /tm...
FAILED tests/cursor_test.py::CursorTest::testKeyValueItemEmpty - lmdb.Error: ...
FAILED tests/cursor_test.py::CursorTest::testLastFilled - lmdb.Error: /tmp/lm...
FAILED tests/cursor_test.py::CursorTest::testPut - lmdb.Error: /tmp/lmdb_test...
FAILED tests/cursor_test.py::CursorTest::testSetKey - lmdb.Error: /tmp/lmdb_t...
FAILED tests/cursor_test.py::CursorTest::testSetRange - lmdb.Error: /tmp/lmdb...
FAILED tests/cursor_test.py::CursorTest2::testIterWithDeletes - lmdb.Error: /...
FAILED tests/cursor_test.py::PutmultiTest::test_2list - lmdb.Error: /tmp/lmdb...
FAILED tests/cursor_test.py::PutmultiTest::test_2list_preserve - lmdb.Error: ...
FAILED tests/cursor_test.py::PutmultiTest::test_bad_seq1 - lmdb.Error: /tmp/l...
FAILED tests/cursor_test.py::PutmultiTest::test_dupsort - lmdb.Error: /tmp/lm...
FAILED tests/cursor_test.py::PutmultiTest::test_dupsort_put_append - lmdb.Err...
FAILED tests/cursor_test.py::PutmultiTest::test_dupsort_putmulti_append - lmd...
FAILED tests/cursor_test.py::PutmultiTest::test_empty_seq - lmdb.Error: /tmp/...
FAILED tests/cursor_test.py::ReplaceTest::test_replace - lmdb.Error: /tmp/lmd...
FAILED tests/cursor_test.py::ContextManagerTest2::test_close - lmdb.Error: /t...
FAILED tests/cursor_test.py::ContextManagerTest2::test_double_close - lmdb.Er...
FAILED tests/cursor_test.py::ContextManagerTest2::test_enter - lmdb.Error: /t...
FAILED tests/cursor_test.py::ContextManagerTest2::test_exit_failure - lmdb.Er...
FAILED tests/cursor_test.py::ContextManagerTest2::test_exit_success - lmdb.Er...
FAILED tests/cursor_test.py::PreloadTest::test_preload - lmdb.Error: /tmp/lmd...
FAILED tests/cursor_test.py::CursorReadOnlyTest::test_cursor_readonly - lmdb....
FAILED tests/env_test.py::OpenTest::test_lock - lmdb.Error: /tmp/lmdb_testd8m...
FAILED tests/env_test.py::OpenTest::test_map_async - lmdb.Error: /tmp/lmdb_te...
FAILED tests/env_test.py::OpenTest::test_max_dbs - lmdb.Error: /tmp/lmdb_test...
FAILED tests/env_test.py::OpenTest::test_max_readers - lmdb.Error: /tmp/lmdb_...
FAILED tests/env_test.py::OpenTest::test_meminit - lmdb.Error: /tmp/lmdb_test...
FAILED tests/env_test.py::OpenTest::test_metasync - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/env_test.py::OpenTest::test_mode_subdir_create - lmdb.Error: /tm...
FAILED tests/env_test.py::OpenTest::test_mode_subdir_nocreate - lmdb.Error: /...
FAILED tests/env_test.py::OpenTest::test_ok_path - lmdb.Error: /tmp/lmdb_test...
FAILED tests/env_test.py::OpenTest::test_readahead - lmdb.Error: /tmp/lmdb_te...
FAILED tests/env_test.py::OpenTest::test_readonly_false - lmdb.Error: /tmp/lm...
FAILED tests/env_test.py::OpenTest::test_readonly_true_exist - lmdb.Error: /t...
FAILED tests/env_test.py::OpenTest::test_subdir_false_junk - lmdb.Error: /tmp...
FAILED tests/env_test.py::OpenTest::test_subdir_false_ok - lmdb.Error: /tmp/l...
FAILED tests/env_test.py::OpenTest::test_subdir_true_exist_create - lmdb.Erro...
FAILED tests/env_test.py::OpenTest::test_subdir_true_exist_nocreate - lmdb.Er...
FAILED tests/env_test.py::OpenTest::test_subdir_true_noexist_create - lmdb.Er...
FAILED tests/env_test.py::OpenTest::test_sync - lmdb.Error: /tmp/lmdb_test5s0...
FAILED tests/env_test.py::OpenTest::test_tiny_size - lmdb.Error: /tmp/lmdb_te...
FAILED tests/env_test.py::OpenTest::test_writemap - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/env_test.py::SetMapSizeTest::test_applied - lmdb.Error: /tmp/lmd...
FAILED tests/env_test.py::SetMapSizeTest::test_invalid - lmdb.Error: /tmp/lmd...
FAILED tests/env_test.py::SetMapSizeTest::test_negative - lmdb.Error: /tmp/lm...
FAILED tests/env_test.py::CloseTest::test_close - lmdb.Error: /tmp/lmdb_tests...
FAILED tests/env_test.py::ContextManagerTest::test_crash - lmdb.Error: /tmp/l...
FAILED tests/env_test.py::ContextManagerTest::test_ok - lmdb.Error: /tmp/lmdb...
FAILED tests/env_test.py::InfoMethodsTest::test_flags - lmdb.Error: /tmp/lmdb...
FAILED tests/env_test.py::InfoMethodsTest::test_info - lmdb.Error: /tmp/lmdb_...
FAILED tests/env_test.py::InfoMethodsTest::test_max_key_size - lmdb.Error: /t...
FAILED tests/env_test.py::InfoMethodsTest::test_max_readers - lmdb.Error: /tm...
FAILED tests/env_test.py::InfoMethodsTest::test_path - lmdb.Error: /tmp/lmdb_...
FAILED tests/env_test.py::InfoMethodsTest::test_readers - lmdb.Error: /tmp/lm...
FAILED tests/env_test.py::InfoMethodsTest::test_stat - lmdb.Error: /tmp/lmdb_...
FAILED tests/env_test.py::OtherMethodsTest::test_copy - lmdb.Error: /tmp/lmdb...
FAILED tests/env_test.py::OtherMethodsTest::test_copy_compact - lmdb.Error: /...
FAILED tests/env_test.py::OtherMethodsTest::test_copyfd - lmdb.Error: /tmp/lm...
FAILED tests/env_test.py::OtherMethodsTest::test_copyfd_compact - lmdb.Error:...
FAILED tests/env_test.py::OtherMethodsTest::test_reader_check - lmdb.Error: /...
FAILED tests/env_test.py::OtherMethodsTest::test_sync - lmdb.Error: /tmp/lmdb...
FAILED tests/env_test.py::BeginTest::test_begin_closed - lmdb.Error: /tmp/lmd...
FAILED tests/env_test.py::BeginTest::test_begin_readonly - lmdb.Error: /tmp/l...
FAILED tests/env_test.py::BeginTest::test_begin_write - lmdb.Error: /tmp/lmdb...
FAILED tests/env_test.py::BeginTest::test_bind_db - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/env_test.py::BeginTest::test_buffers - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/env_test.py::BeginTest::test_parent - lmdb.Error: /tmp/lmdb_test...
FAILED tests/env_test.py::BeginTest::test_parent_readonly - lmdb.Error: /tmp/...
FAILED tests/env_test.py::OpenDbTest::test_flags - lmdb.Error: /tmp/lmdb_test...
FAILED tests/env_test.py::OpenDbTest::test_main - lmdb.Error: /tmp/lmdb_testv...
FAILED tests/env_test.py::OpenDbTest::test_readonly_env_main - lmdb.Error: /t...
FAILED tests/env_test.py::OpenDbTest::test_readonly_env_sub - lmdb.Error: /tm...
FAILED tests/env_test.py::OpenDbTest::test_readonly_env_sub_eperm - lmdb.Erro...
FAILED tests/env_test.py::OpenDbTest::test_readonly_env_sub_noexist - lmdb.Er...
FAILED tests/env_test.py::OpenDbTest::test_reopen - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/env_test.py::OpenDbTest::test_sub_notxn - lmdb.Error: /tmp/lmdb_...
FAILED tests/env_test.py::OpenDbTest::test_sub_rotxn - lmdb.Error: /tmp/lmdb_...
FAILED tests/env_test.py::OpenDbTest::test_sub_txn - lmdb.Error: /tmp/lmdb_te...
FAILED tests/env_test.py::OpenDbTest::test_unicode - lmdb.Error: /tmp/lmdb_te...
FAILED tests/env_test.py::SpareTxnTest::test_none - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/env_test.py::SpareTxnTest::test_one - lmdb.Error: /tmp/lmdb_test...
FAILED tests/env_test.py::LeakTest::test_open_close_does_not_leak - lmdb.Erro...
FAILED tests/env_test.py::LeakTest::test_open_unref_does_not_leak - lmdb.Erro...
FAILED tests/env_test.py::LeakTest::test_weakref_callback_invoked_once - lmdb...
FAILED tests/getmulti_test.py::GetMultiTestNoDupsortNoDupfixed::testGetMulti
FAILED tests/getmulti_test.py::GetMultiTestDupsortNoDupfixed::testGetMulti - ...
FAILED tests/getmulti_test.py::GetMultiTestDupsortDupfixed::testGetMulti - lm...
FAILED tests/getmulti_test.py::GetMultiTestDupsortDupfixedKeyfixed::testGetMulti
FAILED tests/iteration_test.py::IterationTest::testFromExistentKeySetKey - lm...
FAILED tests/iteration_test.py::IterationTest::testFromExistentKeySetRange - ...
FAILED tests/iteration_test.py::IterationTest::testFromLastKey - lmdb.Error: ...
FAILED tests/iteration_test.py::IterationTest::testFromNonExistentKeyPastEnd
FAILED tests/iteration_test.py::IterationTest::testFromNonExistentKeySetRange
FAILED tests/iteration_test.py::IterationTest::testFromStart - lmdb.Error: /t...
FAILED tests/iteration_test.py::IterationTest::testFromStartWithIternext - lm...
FAILED tests/iteration_test.py::IterationTest::testFromStartWithNext - lmdb.E...
FAILED tests/iteration_test.py::ReverseIterationTest::testFromExistentKeySetKeyRev
FAILED tests/iteration_test.py::ReverseIterationTest::testFromExistentKeySetRangeRev
FAILED tests/iteration_test.py::ReverseIterationTest::testFromLastKeyRev - lm...
FAILED tests/iteration_test.py::ReverseIterationTest::testFromLastKeyWithPrevRev
FAILED tests/iteration_test.py::ReverseIterationTest::testFromNonExistentKeyPastEndRev
FAILED tests/iteration_test.py::ReverseIterationTest::testFromNonExistentKeySetRangeRev
FAILED tests/iteration_test.py::ReverseIterationTest::testFromStartRev - lmdb...
FAILED tests/iteration_test.py::SeekIterationTest::testDeleteDuringIteration
FAILED tests/iteration_test.py::SeekIterationTest::testForwardIterationSeek
FAILED tests/iteration_test.py::SeekIterationTest::testPutDuringIteration - l...
FAILED tests/tool_test.py::ToolTest::test_cmd_get - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/tool_test.py::ToolTest::test_cmd_rewrite - lmdb.Error: /tmp/lmdb...
FAILED tests/txn_test.py::InitTest::test_begin_write - lmdb.Error: /tmp/lmdb_...
FAILED tests/txn_test.py::InitTest::test_bind_db - lmdb.Error: /tmp/lmdb_test...
FAILED tests/txn_test.py::InitTest::test_bind_db_methods - lmdb.Error: /tmp/l...
FAILED tests/txn_test.py::InitTest::test_buffers - lmdb.Error: /tmp/lmdb_test...
FAILED tests/txn_test.py::InitTest::test_closed - lmdb.Error: /tmp/lmdb_test4...
FAILED tests/txn_test.py::InitTest::test_parent - lmdb.Error: /tmp/lmdb_testu...
FAILED tests/txn_test.py::InitTest::test_parent_readonly - lmdb.Error: /tmp/l...
FAILED tests/txn_test.py::InitTest::test_readonly - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/txn_test.py::ContextManagerTest::test_crash - lmdb.Error: /tmp/l...
FAILED tests/txn_test.py::ContextManagerTest::test_ok - lmdb.Error: /tmp/lmdb...
FAILED tests/txn_test.py::IdTest::test_invalid_txn - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::IdTest::test_readonly_after_write - lmdb.Error: /tm...
FAILED tests/txn_test.py::IdTest::test_readonly_new - lmdb.Error: /tmp/lmdb_t...
FAILED tests/txn_test.py::IdTest::test_write_new - lmdb.Error: /tmp/lmdb_test...
FAILED tests/txn_test.py::StatTest::test_stat - lmdb.Error: /tmp/lmdb_testzio...
FAILED tests/txn_test.py::DropTest::test_delete - lmdb.Error: /tmp/lmdb_testm...
FAILED tests/txn_test.py::DropTest::test_double_delete - lmdb.Error: /tmp/lmd...
FAILED tests/txn_test.py::DropTest::test_empty - lmdb.Error: /tmp/lmdb_testsi...
FAILED tests/txn_test.py::CommitTest::test_bad_env - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::CommitTest::test_bad_txn - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::CommitTest::test_commit_ro - lmdb.Error: /tmp/lmdb_...
FAILED tests/txn_test.py::CommitTest::test_commit_rw - lmdb.Error: /tmp/lmdb_...
FAILED tests/txn_test.py::AbortTest::test_abort_ro - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::AbortTest::test_abort_rw - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::GetTest::test_bad_env - lmdb.Error: /tmp/lmdb_testy...
FAILED tests/txn_test.py::GetTest::test_bad_txn - lmdb.Error: /tmp/lmdb_testo...
FAILED tests/txn_test.py::GetTest::test_buffers_no - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::GetTest::test_buffers_yes - lmdb.Error: /tmp/lmdb_t...
FAILED tests/txn_test.py::GetTest::test_db - lmdb.Error: /tmp/lmdb_testutvnbr...
FAILED tests/txn_test.py::GetTest::test_dupfixed - lmdb.Error: /tmp/lmdb_test...
FAILED tests/txn_test.py::GetTest::test_dupsort - lmdb.Error: /tmp/lmdb_test3...
FAILED tests/txn_test.py::GetTest::test_empty_key - lmdb.Error: /tmp/lmdb_tes...
FAILED tests/txn_test.py::GetTest::test_integerdup - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::GetTest::test_integerkey - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::GetTest::test_missing - lmdb.Error: /tmp/lmdb_teste...
FAILED tests/txn_test.py::PutTest::test_bad_env - lmdb.Error: /tmp/lmdb_testn...
FAILED tests/txn_test.py::PutTest::test_bad_txn - lmdb.Error: /tmp/lmdb_testk...
FAILED tests/txn_test.py::PutTest::test_dupdata_no_dupsort - lmdb.Error: /tmp...
FAILED tests/txn_test.py::PutTest::test_dupsort - lmdb.Error: /tmp/lmdb_test1...
FAILED tests/txn_test.py::PutTest::test_empty_key_value - lmdb.Error: /tmp/lm...
FAILED tests/txn_test.py::PutTest::test_ro_txn - lmdb.Error: /tmp/lmdb_testkw...
FAILED tests/txn_test.py::ReplaceTest::test_bad_env - lmdb.Error: /tmp/lmdb_t...
FAILED tests/txn_test.py::ReplaceTest::test_bad_txn - lmdb.Error: /tmp/lmdb_t...
FAILED tests/txn_test.py::ReplaceTest::test_dupdata_no_dupsort - lmdb.Error: ...
FAILED tests/txn_test.py::ReplaceTest::test_dupsort_del_none - lmdb.Error: /t...
FAILED tests/txn_test.py::ReplaceTest::test_dupsort_noexist - lmdb.Error: /tm...
FAILED tests/txn_test.py::ReplaceTest::test_empty_key_value - lmdb.Error: /tm...
FAILED tests/txn_test.py::ReplaceTest::test_ro_txn - lmdb.Error: /tmp/lmdb_te...
FAILED tests/txn_test.py::LeakTest::test_open_close - lmdb.Error: /tmp/lmdb_t...
======================== 183 failed, 7 passed in 28.87s ========================
==> ERROR: A failure occurred in check().
    Aborting...