diff --git a/.appveyor.yml b/.appveyor.yml
index 3cf76822..a5621af1 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -3,34 +3,42 @@ environment:
         - PYTHON: "C:\\Python35"
           PYTHON_VERSION: "3.5.x"
           PYTHON_ARCH: "32"
+          TOX_APPVEYOR_X64: 0
 
         - PYTHON: "C:\\Python35-x64"
           PYTHON_VERSION: "3.5.x"
           PYTHON_ARCH: "64"
+          TOX_APPVEYOR_X64: 1
 
         - PYTHON: "C:\\Python36"
           PYTHON_VERSION: "3.6.x"
           PYTHON_ARCH: "32"
+          TOX_APPVEYOR_X64: 0
 
         - PYTHON: "C:\\Python36-x64"
           PYTHON_VERSION: "3.6.x"
           PYTHON_ARCH: "64"
+          TOX_APPVEYOR_X64: 1
 
         - PYTHON: "C:\\Python37"
           PYTHON_VERSION: "3.7.x"
           PYTHON_ARCH: "32"
+          TOX_APPVEYOR_X64: 0
 
         - PYTHON: "C:\\Python37-x64"
           PYTHON_VERSION: "3.7.x"
           PYTHON_ARCH: "64"
+          TOX_APPVEYOR_X64: 1
 
         - PYTHON: "C:\\Python38"
           PYTHON_VERSION: "3.8.x"
           PYTHON_ARCH: "32"
+          TOX_APPVEYOR_X64: 0
 
         - PYTHON: "C:\\Python38-x64"
           PYTHON_VERSION: "3.8.x"
           PYTHON_ARCH: "64"
+          TOX_APPVEYOR_X64: 1
 
 install:
     # Prepend newly installed Python to the PATH of this build (this cannot be
@@ -40,15 +48,17 @@ install:
 
     # Upgrade pip
     - "python -m pip install --user --upgrade pip setuptools wheel"
+    - "python -m pip install tox-appveyor"
 
     # Install testing requirements
-    - "pip install -r requirements_test.txt"
+    #- "pip install -r requirements_test.txt"
 
 build: false
 
 test_script:
     - "check-manifest"
-    - "python setup.py sdist bdist_wheel"
-    - "twine check dist/*"
-    - "pip install ."
-    - "pytest"
+    - "python -m tox"
+    #- "python setup.py sdist bdist_wheel"
+    #- "twine check dist/*"
+    #- "pip install ."
+    #- "pytest"
diff --git a/.travis.yml b/.travis.yml
index 42323a8a..5b8913c5 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,14 +12,12 @@ install:
   - sudo apt-get update -qq
   - sudo apt-get install -qq libhdf5-serial-dev
   - python -m pip install --upgrade pip setuptools wheel
-  - pip install -r requirements_test.txt
+  - pip install tox-travis
+  #- pip install -r requirements_test.txt
 
 script:
   - check-manifest
-  - python setup.py sdist bdist_wheel
-  - twine check dist/*
-  - pip install .
-  - pytest
+  - tox
 
 # Run code coverage
 after_success: codecov
diff --git a/MANIFEST.in b/MANIFEST.in
index 01c0ebf8..0ca2e0c2 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -11,4 +11,10 @@ exclude .nojekyll
 exclude .pylintrc
 exclude paper*
 recursive-exclude * __pycache__
-recursive-exclude * *.py[co]
+recursive-exclude * *.py[co] *.bk
+recursive-exclude * old .old
+recursive-exclude * *.tox
+exclude hickle/tests/classes
+recursive-exclude hickle/tests/classes *
+exclude hickle/tests/dev_check
+recursive-exclude hickle/tests/dev_check *
diff --git a/conftest.py b/conftest.py
new file mode 100644
index 00000000..1e536f9e
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,457 @@
+import pytest
+import sys
+import types
+import functools as ft
+import threading
+import os
+import os.path
+import importlib
+import collections
+import ctypes
+
+# list of function names which shall not be
+# traced when compression keyword hardening
+# test run is executed
+non_core_loader_functions = {
+    'type_legacy_mro',
+    'load_pickled_data',
+    'load_compact_dataset',
+    'register_compact_expand',
+    '_moc_numpy_array_object_lambda',
+    'fix_lambda_obj_type',
+    'LoaderManager.load_loader',
+    'CompactContainer.convert',
+    'NoContainer.convert',
+    '_DictItemContainer.convert',
+    'ExpandReferenceContainer.convert',
+    'CompactContainer.filter',
+    'ExpandReferenceContainer.filter',
+    'ReferenceManager.resolve_type',
+    'CompactContainer._append'
+}
+
+def pytest_addoption(parser):
+    """
+    adds enable_compression keywort to pytest commandline options
+    for enabling h5py compression keyword hardening testing of
+    dump functions of hikcle.loaders  and hickle core loaders
+    """
+    parser.addoption(
+        "--enable-compression",
+        action='store',
+        nargs='?',
+        const=6,
+        type=int,
+        choices=range(0,10),
+        help="run all tests with bzip compression enabled. Optionally specify compression level 0-9 (default 6)",
+        dest="enable_compression"
+    )
+
+def _get_trace_function(trace_function):
+    """
+    try to get hold of FunctionType object of passed in Method, Function or callable
+    """
+    while not isinstance(trace_function,(types.FunctionType,types.LambdaType,types.BuiltinFunctionType)):
+        if isinstance(trace_function,(types.MethodType,types.BuiltinMethodType)):
+            trace_function = getattr(trace_function,'__func__')
+            continue
+        if isinstance(trace_function,ft.partial):
+            trace_function = trace_function.func
+            continue
+        return (
+            getattr(trace_function,'__call__',trace_function) 
+            if callable(trace_function) and not isinstance(trace_function,type) else
+            None
+        )
+    return trace_function
+
+# keyword arguments to yield from compression_kwargs fixture below
+# may in future become a list of dictionaries to be yieled for
+# running same test with different sets of compression keywors
+# (implizit parametrization of tests)
+_compression_args =  dict(
+    compression='gzip',
+    compression_opts=6
+)
+_test_compression = None
+
+def pytest_configure(config):
+    """
+    make no_compression mark available from pytest.mark.
+    if not yet activated enable profiling of dump methods and functions
+    and set compression_level selected on commandline if explicitly
+    specified.
+    """
+    global _test_compression
+
+    config.addinivalue_line(
+        "markers","no_compression: do not enforce h5py comression hardening testing"
+    )
+    if _test_compression is not None:
+        return
+    compression_level = config.getoption("enable_compression",default=-1)
+    if compression_level is None or compression_level < 0:
+        return
+    _compression_args['compression_opts'] = compression_level
+    _test_compression = True
+
+# local handle of no_compression mark
+no_compression = pytest.mark.no_compression
+
+@pytest.fixture#(scope='session')
+def compression_kwargs(request):
+    """
+    fixture providing the compressoin related keyword arguments
+    to be passed to any test not marked with no_compression mark
+    and expecting compression_kwargs as one of its parameters 
+    """
+    global _test_compression
+    yield ( _compression_args if _test_compression else {} )
+
+# list of distinct copyies of LoaderManager.register_class function
+# keys are either "<filename>::LoaderManager.register_class" or
+# copy of code object executed when LoaderManager.register_class method
+# is called
+_trace_register_class = {}
+
+# list of dump_functions to be traced with respect to beeing
+# passed the compression related keywords provided throug compression_kwargs
+# fixture above. In case a call to any of theses does not include at least these
+# keywords an AssertionError Exception is raised.
+_trace_functions = collections.OrderedDict()
+
+# profiling function to be called after execution of _trace_loader_funcs
+# below
+_trace_profile_call = None
+
+# index of dump_function argument in argument list of LoaderManager.register_class
+# method. 
+_trace_function_argument_default = -1
+def _chain_profile_call(frame,event,arg):
+    global _trace_profile_call
+    if _trace_profile_call:
+        next_call = _trace_profile_call(frame,event,arg)
+        if next_call:
+            _trace_profile_call = next_call
+
+# argument names which correspond to argument beeing passed dump_function
+# object
+_trace_function_arg_names = {'dump_function'}
+
+
+# the pytest session tracing of proper handling of compression related
+# keywords is activated for
+_traced_session = None
+
+def pytest_sessionstart(session):
+    """
+    pytest hook called at start of session.
+    - collects all functions exported by hickle.lookup module (for now) and
+      records inserts "<filename>::<function.__qualname__>" strings into
+      _trace_functions list for any not listed in above non_core_loader_functions
+    - collects all dump_functions listed in class_register tables of all
+      hickle.loaders.load_*.py modules.
+    """
+    global _test_compression,_traced_session,_trace_register_class,_trace_functions,_trace_profile_call
+    if _test_compression is None:
+        pytest_configure(session.config)
+    if not _test_compression:
+        return None
+    # extract all loader function from hickle.lookup
+    lookup_module = sys.modules.get('hickle.lookup',None)
+    if not isinstance(lookup_module,types.ModuleType):
+        lookup_module_spec = importlib.util.find_spec("hickle.lookup")
+        
+        lookup_module = importlib.util.module_from_spec(lookup_module_spec)
+        lookup_module_spec.loader.exec_module(lookup_module)
+    register_class = lookup_module.LoaderManager.register_class
+    register_class_code = register_class.__func__.__code__
+    trace_function_argument = register_class_code.co_argcount + register_class_code.co_kwonlyargcount
+    for argid,trace_function in ( (count,varname) for count,varname in enumerate(register_class_code.co_varnames[:(register_class_code.co_argcount + register_class_code.co_kwonlyargcount)]) if varname in _trace_function_arg_names ):
+        trace_function_argument = argid
+        break
+    if trace_function_argument < 0:
+        return None
+    _trace_function_argument_default = trace_function_argument
+    qualname = getattr(register_class,'__qualname__',register_class.__name__)
+    code_name = qualname if qualname.rsplit('.',1) == register_class_code.co_name else register_class_code.co_name
+    _trace_register_class.update({"{}::{}".format(register_class_code.co_filename,code_name):trace_function_argument})
+    for loader_func_name,loader_func in ( 
+        (func_name,func) 
+        for name, item in lookup_module.__dict__.items() 
+        if isinstance(item,(types.FunctionType,type))
+        for func_name,func in ( 
+            ((name,item),)
+            if isinstance(item,types.FunctionType) else 
+            ( 
+                ( meth_name,meth) 
+                for meth_name,meth in item.__dict__.items() 
+                if isinstance(meth,types.FunctionType) 
+            ) 
+        )
+        if func_name[:2] != '__' and func_name[-2:] != '__' 
+    ):
+        loader_func = _get_trace_function(loader_func)
+        if loader_func is not None and loader_func.__module__ == lookup_module.__name__:
+            code = loader_func.__code__
+            qualname = getattr(loader_func,'__qualname__',loader_func.__name__) 
+            if qualname not in non_core_loader_functions:
+                code_name = qualname if qualname.rsplit('.',1) == code.co_name else code.co_name
+                _trace_functions["{}::{}".format(code.co_filename,code_name)] = (loader_func.__module__,qualname)
+    # extract all dump functions from any known loader module
+    hickle_loaders_path = os.path.join(os.path.dirname(lookup_module.__file__),'loaders')
+    for loader in os.scandir(hickle_loaders_path):
+        if not loader.is_file() or not loader.name.startswith('load_'):
+            continue
+        loader_module_name = "hickle.loaders.{}".format(loader.name.rsplit('.',1)[0])
+        loader_module = sys.modules.get(loader_module_name,None)
+        if loader_module is None:
+            
+            loader_module_spec = importlib.util.find_spec("hickle.loaders.{}".format(loader.name.rsplit('.',1)[0]))
+            if loader_module_spec is None:
+                continue
+            loader_module = importlib.util.module_from_spec(loader_module_spec)
+            try:
+                loader_module_spec.loader.exec_module(loader_module)
+            except ModuleNotFoundError:
+                continue
+            except ImportError:
+                if sys.version_info[0] > 3 or sys.version_info[1] > 5:
+                    raise
+                continue
+        class_register_table = getattr(loader_module,'class_register',())
+        # trace function has cls/self
+        for dump_function in ( entry[trace_function_argument-1] for entry in class_register_table ):
+            dump_function = _get_trace_function(dump_function)
+            if dump_function is not None:
+                code = dump_function.__code__
+                qualname = getattr(dump_function,'__qualname__',dump_function.__name__)
+                code_name = qualname if qualname.rsplit('.',1) == code.co_name else code.co_name
+                _trace_functions["{}::{}".format(code.co_filename,code_name)] = (dump_function.__module__,qualname)
+    # activate compression related profiling
+    _trace_profile_call = sys.getprofile()
+    _traced_session = session
+    sys.setprofile(_trace_loader_funcs)
+    return None
+
+# List of test functions which are marked by no_compression mark
+_never_trace_compression = set()
+
+def traceback_from_frame(frame,stopafter):
+    """
+    helper function used in Python >= 3.7 to beautify traceback
+    of AssertionError exceptoin thrown by _trace_loader_funcs
+    """
+    tb = types.TracebackType(None,frame,frame.f_lasti,frame.f_lineno)
+    while frame.f_back is not stopafter.f_back:
+        frame = frame.f_back
+        tb = types.TracebackType(tb,frame,frame.f_lasti,frame.f_lineno)
+    return tb
+
+    
+def pytest_collection_finish(session):
+    """
+    collect all test functions for which comression related keyword monitoring
+    shall be disabled.
+    """
+    if not sys.getprofile() == _trace_loader_funcs:
+        return 
+
+    listed = set()
+    listemodules = set()
+    for item in session.items:
+        func = item.getparent(pytest.Function)
+        if func not in listed:
+            listed.add(func)
+            for marker in func.iter_markers(no_compression.name):
+                never_trace_code = func.function.__code__
+                qualname = getattr(func.function,'__qualname__',func.function.__name__)
+                code_name = qualname if qualname.rsplit('.',1) == never_trace_code.co_name else never_trace_code.co_name
+                _never_trace_compression.add("{}::{}".format(never_trace_code.co_filename,code_name))
+                break
+        
+
+def _trace_loader_funcs(frame,event,arg,nochain=False):
+    """
+    does the actuatual profiling with respect to proper passing compression keywords
+    to dump_functions
+    """
+    global _chain_profile_call, _trace_functions,_never_trace_compression,_trace_register_class,_trace_function_argument_default
+    try:
+        if event not in {'call','c_call'}:
+            return _trace_loader_funcs
+        # check if LoaderManager.register_class has been called
+        # if get position of dump_function argument and extract
+        # code object for dump_function to be registered if not None
+        code_block = frame.f_code
+        trace_function_argument = _trace_register_class.get(code_block,None)
+        if trace_function_argument is not None:
+            trace_function = frame.f_locals.get(code_block.co_varnames[trace_function_argument],None)
+            load_function = frame.f_locals.get(code_block.co_varnames[trace_function_argument+1],None)
+            if load_function is not None:
+                load_function = _get_trace_function(load_function)
+                _trace_functions.pop("{}::{}".format(load_function.__code__.co_filename,load_function.__code__.co_name),None)
+            if trace_function is None:
+                return _trace_loader_funcs
+            trace_function = _get_trace_function(trace_function)
+            if trace_function is None:
+                return _trace_loader_funcs
+            trace_function_code = getattr(trace_function,'__code__',None)
+            if trace_function_code is not None:
+                # store code object corresponding to dump_function in _trace_functions list
+                # if not yet present there. 
+                qualname = getattr(trace_function,'__qualname__',trace_function.__name__)
+                code_name = qualname if qualname.rsplit('.',1) == trace_function_code.co_name else trace_function_code.co_name
+                trace_function_code_name = "{}::{}".format(trace_function_code.co_filename,code_name)
+                if (
+                    trace_function_code_name not in _trace_register_class and
+                    ( 
+                        trace_function_code_name not in _trace_functions or
+                        trace_function_code not in _trace_functions
+                    )
+                ):
+                    trace_function_spec = (trace_function.__module__,qualname)
+                    _trace_functions[trace_function_code] = trace_function_spec
+                    _trace_functions[trace_function_code_name] = trace_function_spec
+            return _trace_loader_funcs
+        # estimate qualname from local variable stored in frame.f_local corresponding
+        # to frame.f_code.co_varnames[0] if any.
+        object_self_name = frame.f_code.co_varnames[:1]
+        if object_self_name:
+            self = frame.f_locals.get(object_self_name[0],None)
+            module = getattr(self,'__module__','')
+            if isinstance(module,str) and module.split('.',1)[0] == 'hickle' and isinstance(getattr(self,'__name__',None),str):
+                method = getattr(self,frame.f_code.co_name,None)
+                if method is not None and getattr(method,'__code__',None) == frame.f_code:
+                    code_name = "{}::{}.{}".format(
+                        frame.f_code.co_filename,
+                        getattr(self,'__qualname__',self.__name__),
+                        frame.f_code.co_name
+                    )
+                else:
+                    code_name = "{}::{}".format(frame.f_code.co_filename,frame.f_code.co_name)
+            else:
+                code_name = "{}::{}".format(frame.f_code.co_filename,frame.f_code.co_name)
+        else:
+            code_name = "{}::{}".format(frame.f_code.co_filename,frame.f_code.co_name)
+        # check if frame could encode a clall to a new incarnation of LoaderManager.register_class
+        # method. Add its code object to the list of known incarnations and rerun above code
+        if code_block.co_name == 'register_class':
+            trace_function_argument = _trace_register_class.get(code_name,None)
+            if trace_function_argument is not None:
+                _trace_register_class[code_block] = trace_function_argument
+                return _trace_loader_funcs(frame,event,arg,True)
+            if (
+                code_block.co_filename.rsplit('/',2) == ['hickle','lookup.py'] and 
+                code_block.co_varnames > trace_function_argument and 
+                code_block.co_varnames[_trace_function_argument_default] in _trace_function_arg_names
+            ):
+                _trace_register_class[code_name] = _trace_function_argument_default
+                _trace_register_class[code_block] = _trace_function_argument_default
+                return _trace_loader_funcs(frame,event,arg,True)
+
+        # frame encodes a call to any other function or method. 
+        # If the function or method is listed in _trace_functions list check
+        # if it received the appropriate set of compresson related keywords
+        function_object_spec = _trace_functions.get(frame.f_code,None)
+        if function_object_spec is None:
+            function_object_spec = _trace_functions.get(code_name,None)
+            if function_object_spec is None:
+                return _trace_loader_funcs
+            _trace_functions[frame.f_code] = function_object_spec
+        baseargs = ( 
+            (arg,frame.f_locals[arg]) 
+            for arg in frame.f_code.co_varnames[:(frame.f_code.co_argcount + frame.f_code.co_kwonlyargcount)]
+        )
+        kwargs = frame.f_locals.get('kwargs',None)
+        if kwargs is not None:
+            fullargs = ( (name,arg) for arglist in (kwargs.items(),baseargs) for name,arg in arglist )
+        else:
+            fullargs = baseargs
+        seen_compression_args = set()
+        for arg,value in fullargs:
+            if arg in seen_compression_args:
+                continue
+            if _compression_args.get(arg,None) is not None:
+                seen_compression_args.add(arg)
+                if len(seen_compression_args) == len(_compression_args):
+                    return _trace_loader_funcs
+        # keywords not passed or filtered prematurely.
+        # walk the stack until reaching executed test function.
+        # if test function is not marked with no_compression raise
+        # AssertionError stating that dump_function did not
+        # receive expected compression keywords defined above
+        # For Python <= 3.6 collect all functions called between current
+        # frame and frame of executed test function. For Python > 3.6 use
+        # above traceback_from_frame function to build traceack showing appropriate
+        # callstack and context excluding this function to ensure AssertionError
+        # exception appears thrown on behlaf of function triggering call encoded by
+        # passed frame
+        function_object_spec = _trace_functions[frame.f_code]
+        if _traced_session is not None:
+            test_list = { 
+                "{}::{}".format(
+                    item.function.__code__.co_filename,
+                    getattr(item.function,'__qualname__',
+                    item.function.__name__)
+                ):item 
+                for item in _traced_session.items
+            }
+            collect_call_tree = []
+            next_frame = frame
+            while next_frame is not None:
+                object_self_name = frame.f_code.co_varnames[:1]
+                if object_self_name:
+                    self = frame.f_locals.get(object_self_name[0])
+                    module = getattr(self,'__module__','')
+                    if (
+                        isinstance(module,str) and 
+                        module.split('.',1)[0] == 'hickle' and 
+                        isinstance(getattr(self,'__name__',None),str)
+                    ):
+                        method = getattr(self,frame.f_code.co_name,None)
+                        if method is not None and getattr(method,'__code__',None) == frame.f_code:
+                            frame_name = "{}::{}".format(
+                                next_frame.f_code.co_filename,
+                                getattr(method,'__qualname__',method.__name__)
+                            )
+                        else:
+                            frame_name = "{}::{}".format(next_frame.f_code.co_filename,next_frame.f_code.co_name)
+                    else:
+                        frame_name = "{}::{}".format(next_frame.f_code.co_filename,next_frame.f_code.co_name)
+                else:
+                    frame_name = "{}::{}".format(next_frame.f_code.co_filename,next_frame.f_code.co_name)
+                if frame_name in _never_trace_compression:
+                    return _trace_loader_funcs
+                in_test = test_list.get(frame_name,None)
+                collect_call_tree.append((next_frame.f_code.co_filename,frame_name,next_frame.f_lineno))
+                if in_test is not None:
+                    try:
+                        tb = traceback_from_frame(frame,next_frame)
+                    except TypeError:
+                        pass
+                    else:
+                        raise AssertionError(
+                            "'{}': compression_kwargs lost in call".format("::".join(function_object_spec))
+                        ).with_traceback(tb)
+                    raise AssertionError(
+                        "'{}': compression_kwargs lost in call:\n\t{}\n".format(
+                            "::".join(function_object_spec),
+                            "\n\t".join("{}::{} ({})".format(*call) for call in collect_call_tree[:0:-1])
+                        )
+                    )
+                next_frame = next_frame.f_back
+    except AssertionError as ae:
+        # check that first entry in traceback does not refer to this function
+        if ae.__traceback__.tb_frame.f_code == _trace_loader_funcs.__code__:
+            ae.__traceback__ = ae.__traceback__.tb_next
+        raise
+    #except Exception as e:
+    #    import traceback;traceback.print_exc()
+    #    import pdb;pdb.set_trace()
+    finally:
+        if not nochain:
+            _chain_profile_call(frame,event,arg)
+
+def pytest_sessionfinish(session):
+    sys.setprofile(_trace_profile_call)
diff --git a/hickle/loaders/load_astropy.py b/hickle/loaders/load_astropy.py
index e5c59204..a9243919 100644
--- a/hickle/loaders/load_astropy.py
+++ b/hickle/loaders/load_astropy.py
@@ -8,6 +8,7 @@
 import numpy as np
 
 # hickle imports
+from hickle.helpers import no_compression
 
 
 # %% FUNCTION DEFINITIONS
@@ -25,7 +26,7 @@ def create_astropy_quantity(py_obj, h_group, name, **kwargs):
     """
 
     d = h_group.create_dataset(name, data=py_obj.value, dtype='float64',
-                               **kwargs)
+                               **no_compression(kwargs))
     d.attrs['unit'] = py_obj.unit.to_string().encode('ascii')
     return d,()
 
@@ -44,7 +45,7 @@ def create_astropy_angle(py_obj, h_group, name, **kwargs):
     """
 
     d = h_group.create_dataset(name, data=py_obj.value, dtype='float64',
-                               **kwargs)
+                               **no_compression(kwargs))
     d.attrs['unit'] = py_obj.unit.to_string().encode('ascii')
     return d,()
 
@@ -118,7 +119,7 @@ def create_astropy_constant(py_obj, h_group, name, **kwargs):
     """
 
     d = h_group.create_dataset(name, data=py_obj.value, dtype='float64',
-                               **kwargs)
+                               **no_compression(kwargs))
     d.attrs["unit"] = py_obj.unit.to_string().encode('ascii')
     d.attrs["abbrev"] = py_obj.abbrev.encode('ascii')
     d.attrs["name"] = py_obj.name.encode('ascii')
diff --git a/hickle/loaders/load_numpy.py b/hickle/loaders/load_numpy.py
index c0733506..fb06fa02 100644
--- a/hickle/loaders/load_numpy.py
+++ b/hickle/loaders/load_numpy.py
@@ -94,7 +94,7 @@ def create_np_array_dataset(py_obj, h_group, name, **kwargs):
             h_node = h_group.create_group(name)
             sub_items = ("data",py_obj,{},kwargs),
     else:
-        h_node = h_group.create_dataset(name, data=py_obj, **kwargs)
+        h_node = h_group.create_dataset(name, data=py_obj, **( no_compression(kwargs) if "bytes" in dtype.name else kwargs ))
         sub_items = ()
     h_node.attrs['np_dtype'] = dtype.str.encode('ascii')
     return h_node,sub_items
diff --git a/hickle/loaders/load_pandas.py b/hickle/loaders/load_pandas.py
index b1a9edf4..4cda663b 100644
--- a/hickle/loaders/load_pandas.py
+++ b/hickle/loaders/load_pandas.py
@@ -1,5 +1,6 @@
 import pandas as pd
 
+print("pandas",pd.__version__)
 # TODO: populate with classes to load
 class_register = []
 exclude_register = []
diff --git a/hickle/tests/test_02_hickle_lookup.py b/hickle/tests/test_02_hickle_lookup.py
index 54f78d9f..dd5b277c 100644
--- a/hickle/tests/test_02_hickle_lookup.py
+++ b/hickle/tests/test_02_hickle_lookup.py
@@ -27,7 +27,7 @@
 from hickle.helpers import PyContainer,not_dumpable
 from hickle.loaders import optional_loaders, attribute_prefix
 import hickle.lookup as lookup
-
+    
 # Set current working directory to the temporary directory
 local.get_temproot().chdir()
 
@@ -542,7 +542,7 @@ def test_type_legacy_mro():
     assert lookup.type_legacy_mro(function_to_dump) == (function_to_dump,)
 
 
-def test_create_pickled_dataset(h5_data):
+def test_create_pickled_dataset(h5_data,compression_kwargs):
     """
     tests create_pickled_dataset, load_pickled_data function and PickledContainer 
     """
@@ -552,7 +552,7 @@ def test_create_pickled_dataset(h5_data):
     py_object = ClassToDump('hello',1)
     data_set_name = "greetings"
     with pytest.warns(lookup.SerializedWarning,match = r".*type\s+not\s+understood,\s+data\s+is\s+serialized:.*") as warner:
-        h5_node,subitems = lookup.create_pickled_dataset(py_object, h5_data,data_set_name)
+        h5_node,subitems = lookup.create_pickled_dataset(py_object, h5_data,data_set_name,**compression_kwargs)
         assert isinstance(h5_node,h5py.Dataset) and not subitems and iter(subitems)
         assert bytes(h5_node[()]) == pickle.dumps(py_object) and h5_node.name.rsplit('/',1)[-1] == data_set_name
         assert lookup.load_pickled_data(h5_node,b'pickle',object) == py_object
@@ -569,6 +569,7 @@ def test__DictItemContainer():
     assert container.convert() is my_bike_lock
 
     
+#@pytest.mark.no_compression
 def test__moc_numpy_array_object_lambda():
     """
     test the _moc_numpy_array_object_lambda function
@@ -583,6 +584,7 @@ def test__moc_numpy_array_object_lambda():
     data = ['hello','world']
     assert lookup._moc_numpy_array_object_lambda(data) == data[0]
     
+#@pytest.mark.no_compression
 def test_fix_lambda_obj_type():
     """
     test _moc_numpy_array_object_lambda function it self. When invokded
@@ -783,26 +785,27 @@ def test_ReferenceManager_context(h5_data):
     assert memo._overlay is None
     read_only_handle.close()
         
-def test_ReferenceManager_store_type(h5_data):
+def test_ReferenceManager_store_type(h5_data,compression_kwargs):
     """
     test ReferenceManager.store_type method which sets 'type' attribute
     reference to appropriate py_obj_type entry within 'hickle_types_table'
     """
     h_node = h5_data.create_group('some_list')
     with lookup.ReferenceManager.create_manager(h5_data) as memo:
-        memo.store_type(h_node,object,None)
+        memo.store_type(h_node,object,None,**compression_kwargs)
         assert len(memo._py_obj_type_table) == 0 and not memo._py_obj_type_link and not memo._base_type_link
         with pytest.raises(lookup.LookupError):
-            memo.store_type(h_node,list,None)
+            memo.store_type(h_node,list,None,**compression_kwargs)
         with pytest.raises(ValueError):
-            memo.store_type(h_node,list,b'')
-        memo.store_type(h_node,list,b'list')
+            memo.store_type(h_node,list,b'',**compression_kwargs)
+        memo.store_type(h_node,list,b'list',**compression_kwargs)
         assert isinstance(h_node.attrs['type'],h5py.Reference)
         type_table_entry = h5_data.file[h_node.attrs['type']]
         assert pickle.loads(type_table_entry[()]) is list
         assert isinstance(type_table_entry.attrs['base_type'],h5py.Reference)
         assert h5_data.file[type_table_entry.attrs['base_type']].name.rsplit('/',1)[-1].encode('ascii') == b'list'
     
+@pytest.mark.no_compression
 def test_ReferenceManager_get_manager(h5_data):
     h_node = h5_data.create_group('some_list')
     item_data = np.array(memoryview(b'hallo welt lore grueszet dich ipsum aus der lore von ipsum gelort in ipsum'),copy=False)
@@ -821,6 +824,7 @@ def test_ReferenceManager_get_manager(h5_data):
     with pytest.raises(lookup.ReferenceError):
         manager = lookup.ReferenceManager.get_manager(h_item)
 
+@pytest.mark.no_compression
 def test_ReferenceManager_resolve_type(h5_data):
     """
     test ReferenceManager.reslove_type method which tries to resolve
@@ -902,7 +906,7 @@ def test_ExpandReferenceContainer(h5_data):
             content = np.array(subitem[()])
             sub_container.append(name,content,subitem.attrs)
 
-def test_create_compact_dataset(h5_data):
+def test_create_compact_dataset(h5_data,compression_kwargs):
     """
     test create_compact_dataset, load_compact_dataset function and 
     CompactContainer object
@@ -914,11 +918,11 @@ def test_create_compact_dataset(h5_data):
     
     data_set_name = ("some_object","some_object_compact","some_object_dataset","some_object_compact_off")
     with pytest.warns(lookup.SerializedWarning,match = r".*type\s+not\s+understood,\s+data\s+is\s+serialized:.*") as warner:
-        h5_node,subitems = lookup.create_compact_dataset(py_obj,h5_data,data_set_name[0])
+        h5_node,subitems = lookup.create_compact_dataset(py_obj,h5_data,data_set_name[0],**compression_kwargs)
         assert isinstance(h5_node,h5py.Dataset) and not subitems and iter(subitems)
         assert bytes(h5_node[()]) == pickle.dumps(py_obj) and h5_node.name.rsplit('/',1)[-1] == data_set_name[0]
         assert lookup.load_pickled_data(h5_node,b'pickle',object) == py_obj
-        h5_node_off,subitems = lookup.create_compact_dataset(py_obj_compact_off,h5_data,data_set_name[3])
+        h5_node_off,subitems = lookup.create_compact_dataset(py_obj_compact_off,h5_data,data_set_name[3],**compression_kwargs)
         assert isinstance(h5_node_off,h5py.Dataset) and not subitems and iter(subitems)
         assert bytes(h5_node_off[()]) == pickle.dumps(py_obj_compact_off) and h5_node_off.name.rsplit('/',1)[-1] == data_set_name[3]
         assert lookup.load_pickled_data(h5_node_off,b'pickle',object) == py_obj_compact_off
@@ -955,13 +959,13 @@ def convert(self):
     
     with lookup.ReferenceManager.create_manager(h5_data) as memo:
         with lookup.LoaderManager.create_manager(h5_data) as loader:
-            h5_node_compact_set,subitems = lookup.create_compact_dataset(py_obj_compact_set,h5_data,data_set_name[2])
-            memo.store_type(h5_node_compact_set,ClassToDumpCompactDataset,b'!compact')
+            h5_node_compact_set,subitems = lookup.create_compact_dataset(py_obj_compact_set,h5_data,data_set_name[2],**compression_kwargs)
+            memo.store_type(h5_node_compact_set,ClassToDumpCompactDataset,b'!compact',**compression_kwargs)
             assert isinstance(h5_node_compact_set,h5py.Dataset) and not subitems and iter(subitems)
             assert h5_node_compact_set.name.rsplit('/',1)[-1] == data_set_name[2]
             assert lookup.load_compact_dataset(h5_node_compact_set,b'!compact!',ClassToDumpCompactDataset) == py_obj_compact_set
-            h5_node_compact,subitems = lookup.create_compact_dataset(py_obj_compact,h5_data,data_set_name[1])
-            memo.store_type(h5_node_compact,ClassToDumpCompact,b'!compact')
+            h5_node_compact,subitems = lookup.create_compact_dataset(py_obj_compact,h5_data,data_set_name[1],**compression_kwargs)
+            memo.store_type(h5_node_compact,ClassToDumpCompact,b'!compact',**compression_kwargs)
             assert isinstance(h5_node_compact,h5py.Group) and subitems and iter(subitems)
             assert h5_node_compact.name.rsplit('/',1)[-1] == data_set_name[1]
             expand_container = lookup.CompactContainer(h5_node_compact.attrs,b'!compact!',ClassToDumpCompact)
@@ -1077,6 +1081,7 @@ def convert(self):
     lookup.LoaderManager.__hkl_container__[None].update(backup__hkl_container__None)
         
 
+@pytest.mark.no_compression
 def test_register_compact_expand():
     """
     test register_compact_expand function
@@ -1110,6 +1115,8 @@ def test_register_compact_expand():
 if __name__ == "__main__":
     from _pytest.monkeypatch import monkeypatch
     from _pytest.fixtures import FixtureRequest
+    from hickle.tests.conftest import compression_kwargs
+
     for table in loader_table():
         test_LoaderManager_register_class(table)
     for table in loader_table():
@@ -1134,8 +1141,11 @@ def test_register_compact_expand():
     ):
             test_LoaderManager_load_loader(table,h5_root,monkey)
     test_type_legacy_mro()
-    for h5_root in h5_data(FixtureRequest(test_create_pickled_dataset)):
-        test_create_pickled_dataset(h5_root)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_pickled_dataset),)
+    ):
+        test_create_pickled_dataset(h5_root,keywords)
     test__DictItemContainer()
     test__moc_numpy_array_object_lambda()
     test_fix_lambda_obj_type()
@@ -1152,14 +1162,19 @@ def test_register_compact_expand():
         test_ReferenceManager_context(h5_root)
     for h5_root in h5_data(FixtureRequest(test_ReferenceManager_get_manager)):
         test_ReferenceManager_get_manager(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_ReferenceManager_store_type)):
-        test_ReferenceManager_store_type(h5_root)
+    for h5_root,compression_kwargs in (
+            h5_data(FixtureRequest(test_ReferenceManager_store_type))
+    ):
+        test_ReferenceManager_store_type(h5_root,compression_kwargs)
     for h5_root in h5_data(FixtureRequest(test_ReferenceManager_resolve_type)):
         test_ReferenceManager_resolve_type(h5_root)
     for h5_root in h5_data(FixtureRequest(test_ExpandReferenceContainer)):
         test_ExpandReferenceContainer(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_create_compact_dataset)):
-        test_create_compact_dataset(h5_root)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_compact_dataset),)
+    ):
+        test_create_compact_dataset(h5_root,keywords)
     test_register_compact_expand()
 
 
diff --git a/hickle/tests/test_03_load_builtins.py b/hickle/tests/test_03_load_builtins.py
index 1e7a7c89..696c2f6c 100644
--- a/hickle/tests/test_03_load_builtins.py
+++ b/hickle/tests/test_03_load_builtins.py
@@ -48,28 +48,28 @@ def h5_data(request):
 
 # %% FUNCTION DEFINITIONS
 
-def test_scalar_dataset(h5_data):
+def test_scalar_dataset(h5_data,compression_kwargs):
     """
     tests creation and loading of datasets for scalar values
     """
 
     # check that scalar value is properly handled
     floatvalue = 5.2
-    h_dataset,subitems= load_builtins.create_scalar_dataset(floatvalue,h5_data,"floatvalue")
+    h_dataset,subitems= load_builtins.create_scalar_dataset(floatvalue,h5_data,"floatvalue",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and h_dataset[()] == floatvalue
     assert not [ item for item in subitems ]
     assert load_builtins.load_scalar_dataset(h_dataset,b'float',float) == floatvalue
 
     # check that intger value less thatn 64 bit is stored as int
     intvalue = 11
-    h_dataset,subitems = load_builtins.create_scalar_dataset(intvalue,h5_data,"intvalue")
+    h_dataset,subitems = load_builtins.create_scalar_dataset(intvalue,h5_data,"intvalue",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and h_dataset[()] == intvalue
     assert not [ item for item in subitems ]
     assert load_builtins.load_scalar_dataset(h_dataset,b'int',int) == intvalue
 
     # check that integer larger than 64 bit is stored as ascii byte string
     non_mappable_int = int(2**65)
-    h_dataset,subitems = load_builtins.create_scalar_dataset(non_mappable_int,h5_data,"non_mappable_int")
+    h_dataset,subitems = load_builtins.create_scalar_dataset(non_mappable_int,h5_data,"non_mappable_int",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset)
     assert bytearray(h_dataset[()]) == str(non_mappable_int).encode('utf8')
     assert not [ item for item in subitems ]
@@ -77,31 +77,31 @@ def test_scalar_dataset(h5_data):
 
     # check that integer larger than 64 bit is stored as ascii byte string
     non_mappable_neg_int = -int(-2**63-1)
-    h_dataset,subitems = load_builtins.create_scalar_dataset(non_mappable_neg_int,h5_data,"non_mappable_neg_int")
+    h_dataset,subitems = load_builtins.create_scalar_dataset(non_mappable_neg_int,h5_data,"non_mappable_neg_int",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset)
     assert bytearray(h_dataset[()]) == str(non_mappable_neg_int).encode('utf8')
     assert not [ item for item in subitems ]
     assert load_builtins.load_scalar_dataset(h_dataset,b'int',int) == non_mappable_neg_int
     
     
-def test_non_dataset(h5_data):
+def test_non_dataset(h5_data,compression_kwargs):
     """
      that None value is properly stored
     """
-    h_dataset,subitems = load_builtins.create_none_dataset(None,h5_data,"None_value")
+    h_dataset,subitems = load_builtins.create_none_dataset(None,h5_data,"None_value",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and h_dataset.shape is None and h_dataset.dtype == 'V1'
     assert not [ item for item in subitems ]
     assert load_builtins.load_none_dataset(h_dataset,b'None',None.__class__) is None
 
 
-def test_listlike_dataset(h5_data):
+def test_listlike_dataset(h5_data,compression_kwargs):
     """
     test storing and loading of list like data 
     """
 
     # check that empty tuple is stored properly
     empty_tuple = ()
-    h_dataset,subitems = load_builtins.create_listlike_dataset(empty_tuple, h5_data, "empty_tuple")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(empty_tuple, h5_data, "empty_tuple",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and h_dataset.size is None
     assert not subitems and iter(subitems)
     assert load_builtins.load_list_dataset(h_dataset,b'tuple',tuple) == empty_tuple
@@ -109,7 +109,7 @@ def test_listlike_dataset(h5_data):
     # check that string data is stored properly stored as array of bytes
     # which supports compression
     stringdata = "string_data"
-    h_dataset,subitems = load_builtins.create_listlike_dataset(stringdata, h5_data, "string_data")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(stringdata, h5_data, "string_data",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not [ item for item in subitems ]
     assert bytearray(h_dataset[()]).decode("utf8") == stringdata
     assert h_dataset.attrs["str_type"].decode("ascii") == 'str'
@@ -118,7 +118,7 @@ def test_listlike_dataset(h5_data):
     # check that byte string is proprly stored as array of bytes which
     # supports compression
     bytesdata = b'bytes_data'
-    h_dataset,subitems = load_builtins.create_listlike_dataset(bytesdata, h5_data, "bytes_data")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(bytesdata, h5_data, "bytes_data",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not [ item for item in subitems ]
     assert bytes(h_dataset[()]) == bytesdata
     assert h_dataset.attrs["str_type"].decode("ascii") == 'bytes'
@@ -132,7 +132,7 @@ def test_listlike_dataset(h5_data):
 
     # check that list of single type is stored as dataset of same type
     homogenous_list = [ 1, 2, 3, 4, 5, 6]
-    h_dataset,subitems = load_builtins.create_listlike_dataset(homogenous_list,h5_data,"homogenous_list")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(homogenous_list,h5_data,"homogenous_list",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not [ item for item in subitems ]
     assert h_dataset[()].tolist() == homogenous_list and h_dataset.dtype == int
     assert load_builtins.load_list_dataset(h_dataset,b'list',list) == homogenous_list
@@ -140,7 +140,7 @@ def test_listlike_dataset(h5_data):
     # check that list of different scalar types for which a least common type exists
     # is stored using a dataset 
     mixed_dtype_list = [ 1, 2.5, 3.8, 4, 5, 6]
-    h_dataset,subitems = load_builtins.create_listlike_dataset(mixed_dtype_list,h5_data,"mixed_dtype_list")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(mixed_dtype_list,h5_data,"mixed_dtype_list",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not [ item for item in subitems ]
     assert h_dataset[()].tolist() == mixed_dtype_list and h_dataset.dtype == float
     assert load_builtins.load_list_dataset(h_dataset,b'list',list) == mixed_dtype_list
@@ -149,7 +149,7 @@ def test_listlike_dataset(h5_data):
     # further check that for groups representing list the index of items is either
     # provided via item_index attribute or can be read from name of item
     not_so_homogenous_list = [ 1, 2, 3, [4],5 ,6 ]
-    h_dataset,subitems = load_builtins.create_listlike_dataset(not_so_homogenous_list,h5_data,"not_so_homogenous_list")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(not_so_homogenous_list,h5_data,"not_so_homogenous_list",**compression_kwargs)
     assert isinstance(h_dataset,h5.Group)
     item_name = "data{:d}"
     index = -1 
@@ -158,9 +158,9 @@ def test_listlike_dataset(h5_data):
     index_from_string = load_builtins.ListLikeContainer(h_dataset.attrs,b'list',list)
     for index,(name,item,attrs,kwargs) in enumerate(iter(subitems1)):
         assert item_name.format(index) == name and item == not_so_homogenous_list[index]
-        assert attrs == {"item_index":index} and kwargs == {}
+        assert attrs == {"item_index":index} and kwargs == compression_kwargs
         if isinstance(item,list):
-            item_dataset,_ = load_builtins.create_listlike_dataset(item,h_dataset,name)
+            item_dataset,_ = load_builtins.create_listlike_dataset(item,h_dataset,name,**compression_kwargs)
         else:
             item_dataset = h_dataset.create_dataset(name,data = item)
         item_dataset.attrs.update(attrs)
@@ -177,7 +177,7 @@ def test_listlike_dataset(h5_data):
     no_num_items_container = load_builtins.ListLikeContainer(no_num_items,b'list',list)
     for index,(name,item,attrs,kwargs) in enumerate(iter(subitems2)):
         assert item_name.format(index) == name and item == not_so_homogenous_list[index]
-        assert attrs == {"item_index":index} and kwargs == {}
+        assert attrs == {"item_index":index} and kwargs == compression_kwargs
         item_dataset = h_dataset.get(name,None)
         no_num_items_container.append(name,item,{})
     assert index + 1 == len(not_so_homogenous_list)
@@ -189,7 +189,7 @@ def test_listlike_dataset(h5_data):
     # from the taile of its name. Also check that ListLikeContainer.append
     # raises exceptoin in case value for item_index already has been loaded
     object_list = [ [4, 5 ] ,6, [ 1, 2, 3 ] ]
-    h_dataset,subitems = load_builtins.create_listlike_dataset(object_list,h5_data,"object_list")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(object_list,h5_data,"object_list",**compression_kwargs)
     assert isinstance(h_dataset,h5.Group)
     item_name = "data{:d}"
     wrong_item_name = item_name + "_ni"
@@ -198,9 +198,9 @@ def test_listlike_dataset(h5_data):
     index_from_string = load_builtins.ListLikeContainer(h_dataset.attrs,b'list',list)
     for index,(name,item,attrs,kwargs) in enumerate(iter(subitems)):
         assert item_name.format(index) == name and item == object_list[index]
-        assert attrs == {"item_index":index} and kwargs == {}
+        assert attrs == {"item_index":index} and kwargs == compression_kwargs
         if isinstance(item,list):
-            item_dataset,_ = load_builtins.create_listlike_dataset(item,h_dataset,name)
+            item_dataset,_ = load_builtins.create_listlike_dataset(item,h_dataset,name,**compression_kwargs)
         else:
             item_dataset = h_dataset.create_dataset(name,data = item)
         item_dataset.attrs.update(attrs)
@@ -224,7 +224,7 @@ def test_listlike_dataset(h5_data):
     # assert that list of strings where first string has lenght 1 is properly mapped
     # to group
     string_list = test_set = ['I','confess','appriciate','hickle','times']
-    h_dataset,subitems = load_builtins.create_listlike_dataset(string_list,h5_data,"string_list")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(string_list,h5_data,"string_list",**compression_kwargs)
     assert isinstance(h_dataset,h5.Group)
     item_name = "data{:d}"
     index = -1 
@@ -232,7 +232,7 @@ def test_listlike_dataset(h5_data):
     index_from_string = load_builtins.ListLikeContainer(h_dataset.attrs,b'list',list)
     for index,(name,item,attrs,kwargs) in enumerate(iter(subitems)):
         assert item_name.format(index) == name and item == string_list[index]
-        assert attrs == {"item_index":index} and kwargs == {}
+        assert attrs == {"item_index":index} and kwargs == compression_kwargs
         item_dataset = h_dataset.create_dataset(name,data = item)
         item_dataset.attrs.update(attrs)
         loaded_list.append(name,item,item_dataset.attrs)
@@ -244,7 +244,7 @@ def test_listlike_dataset(h5_data):
     # assert that list which contains numeric values and strings is properly mapped
     # to group
     mixed_string_list = test_set = [12,2.8,'I','confess','appriciate','hickle','times']
-    h_dataset,subitems = load_builtins.create_listlike_dataset(mixed_string_list,h5_data,"mixed_string_list")
+    h_dataset,subitems = load_builtins.create_listlike_dataset(mixed_string_list,h5_data,"mixed_string_list",**compression_kwargs)
     assert isinstance(h_dataset,h5.Group)
     item_name = "data{:d}"
     index = -1 
@@ -252,7 +252,7 @@ def test_listlike_dataset(h5_data):
     index_from_string = load_builtins.ListLikeContainer(h_dataset.attrs,b'list',list)
     for index,(name,item,attrs,kwargs) in enumerate(iter(subitems)):
         assert item_name.format(index) == name and item == mixed_string_list[index]
-        assert attrs == {"item_index":index} and kwargs == {}
+        assert attrs == {"item_index":index} and kwargs == compression_kwargs
         item_dataset = h_dataset.create_dataset(name,data = item)
         item_dataset.attrs.update(attrs)
         loaded_list.append(name,item,item_dataset.attrs)
@@ -262,14 +262,14 @@ def test_listlike_dataset(h5_data):
     assert index_from_string.convert() == mixed_string_list
     
 
-def test_set_container(h5_data):
+def test_set_container(h5_data,compression_kwargs):
     """
     tests storing and loading of set
     """
 
     # check that set of strings is store as group
     test_set = {'I','confess','appriciate','hickle','times'}
-    h_setdataset,subitems = load_builtins.create_setlike_dataset(test_set,h5_data,"test_set")
+    h_setdataset,subitems = load_builtins.create_setlike_dataset(test_set,h5_data,"test_set",**compression_kwargs)
     set_container = load_builtins.SetLikeContainer(h_setdataset.attrs,b'set',set)
     for name,item,attrs,kwargs in subitems:
         set_container.append(name,item,attrs)
@@ -277,27 +277,27 @@ def test_set_container(h5_data):
 
     # check that set of single bytes is stored as single dataset
     test_set_2 = set(b"hello world")
-    h_setdataset,subitems = load_builtins.create_setlike_dataset(test_set_2,h5_data,"test_set_2")
+    h_setdataset,subitems = load_builtins.create_setlike_dataset(test_set_2,h5_data,"test_set_2",**compression_kwargs)
     assert isinstance(h_setdataset,h5.Dataset) and set(h_setdataset[()]) == test_set_2
     assert not subitems and iter(subitems)
     assert load_builtins.load_list_dataset(h_setdataset,b'set',set) == test_set_2
 
     # check that set containing byte strings is stored as group
     test_set_3 = set((item.encode("utf8") for item in test_set))
-    h_setdataset,subitems = load_builtins.create_setlike_dataset(test_set_3,h5_data,"test_set_3")
+    h_setdataset,subitems = load_builtins.create_setlike_dataset(test_set_3,h5_data,"test_set_3",**compression_kwargs)
     set_container = load_builtins.SetLikeContainer(h_setdataset.attrs,b'set',set)
     for name,item,attrs,kwargs in subitems:
         set_container.append(name,item,attrs)
     assert set_container.convert() == test_set_3
 
     # check that empty set is represented by emtpy dataset
-    h_setdataset,subitems = load_builtins.create_setlike_dataset(set(),h5_data,"empty_set")
+    h_setdataset,subitems = load_builtins.create_setlike_dataset(set(),h5_data,"empty_set",**compression_kwargs)
     assert isinstance(h_setdataset,h5.Dataset) and h_setdataset.size == 0
     assert not subitems and iter(subitems)
     assert load_builtins.load_list_dataset(h_setdataset,b'set',set) == set()
     
 
-def test_dictlike_dataset(h5_data):
+def test_dictlike_dataset(h5_data,compression_kwargs):
     """
     test storing and loading of dict
     """
@@ -321,7 +321,7 @@ class KeyClass():
     # check that string and byte string keys are mapped to dataset or group name 
     # check that scalar dict keys are converted to their string representation
     # check that for all other keys a key value pair is created
-    h_datagroup,subitems = load_builtins.create_dictlike_dataset(allkeys_dict,h5_data,"allkeys_dict")
+    h_datagroup,subitems = load_builtins.create_dictlike_dataset(allkeys_dict,h5_data,"allkeys_dict",**compression_kwargs)
     assert isinstance(h_datagroup,h5.Group)
     invalid_key = b''
     last_entry = -1
@@ -380,7 +380,7 @@ class KeyClass():
 
     # check that order of OrderedDict dict keys is not altered on loading data from 
     # hickle file
-    h_datagroup,subitems = load_builtins.create_dictlike_dataset(ordered_dict,h5_data,"ordered_dict")
+    h_datagroup,subitems = load_builtins.create_dictlike_dataset(ordered_dict,h5_data,"ordered_dict",**compression_kwargs)
     assert isinstance(h_datagroup,h5.Group)
     last_entry = -1
     load_ordered_dict = load_builtins.DictLikeContainer(h_datagroup.attrs,b'dict',collections.OrderedDict)
@@ -408,16 +408,32 @@ class KeyClass():
 # %% MAIN SCRIPT
 if __name__ == "__main__":
     from _pytest.fixtures import FixtureRequest
-    for h5_root in h5_data(FixtureRequest(test_scalar_dataset)):
-        test_scalar_dataset(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_non_dataset)):
-        test_non_dataset(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_listlike_dataset)):
-        test_listlike_dataset(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_set_container)):
-        test_set_container(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_dictlike_dataset)):
-        test_dictlike_dataset(h5_root)
+    from hickle.tests.conftest import compression_kwargs
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_scalar_dataset),)
+    ):
+        test_scalar_dataset(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_non_dataset),)
+    ):
+        test_non_dataset(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_listlike_dataset),)
+    ):
+        test_listlike_dataset(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_set_container),)
+    ):
+        test_set_container(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_dictlike_dataset),)
+    ):
+        test_dictlike_dataset(h5_root,keywords)
 
     
     
diff --git a/hickle/tests/test_04_load_numpy.py b/hickle/tests/test_04_load_numpy.py
index 7bfe086f..7396dd9b 100644
--- a/hickle/tests/test_04_load_numpy.py
+++ b/hickle/tests/test_04_load_numpy.py
@@ -57,7 +57,7 @@ def h5_data(request):
 
 # %% FUNCTION DEFINITIONS
 
-def test_create_np_scalar(h5_data):
+def test_create_np_scalar(h5_data,compression_kwargs):
     """
     tests proper storage and loading of numpy scalars
     """
@@ -65,7 +65,7 @@ def test_create_np_scalar(h5_data):
     # check that scalar dataset is created for nupy scalar
     scalar_data = np.float64(np.pi)
     dtype = scalar_data.dtype
-    h_dataset,subitems = load_numpy.create_np_scalar_dataset(scalar_data,h5_data,"scalar_data")
+    h_dataset,subitems = load_numpy.create_np_scalar_dataset(scalar_data,h5_data,"scalar_data",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and iter(subitems) and not subitems
     assert h_dataset.attrs['np_dtype'] == dtype.str.encode('ascii')
     assert  h_dataset[()] == scalar_data
@@ -74,22 +74,22 @@ def test_create_np_scalar(h5_data):
     # check that numpy.bool_ scarlar is properly stored and reloaded
     scalar_data = np.bool_(True)
     dtype = scalar_data.dtype
-    h_dataset,subitems = load_numpy.create_np_scalar_dataset(scalar_data,h5_data,"generic_data")
+    h_dataset,subitems = load_numpy.create_np_scalar_dataset(scalar_data,h5_data,"generic_data",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and iter(subitems) and not subitems
     assert h_dataset.attrs['np_dtype'] == dtype.str.encode('ascii') and h_dataset[()] == scalar_data
     assert load_numpy.load_np_scalar_dataset(h_dataset,b'np_scalar',scalar_data.__class__) == scalar_data
 
-def test_create_np_dtype(h5_data):
+def test_create_np_dtype(h5_data,compression_kwargs):
     """
     test proper creation and loading of dataset representing numpy dtype
     """ 
     dtype = np.dtype(np.int16)
-    h_dataset,subitems = load_numpy.create_np_dtype(dtype, h5_data,"dtype_string")
+    h_dataset,subitems = load_numpy.create_np_dtype(dtype, h5_data,"dtype_string",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and iter(subitems) and not subitems
     assert bytes(h_dataset[()]).decode('ascii') == dtype.str
     assert load_numpy.load_np_dtype_dataset(h_dataset,'np_dtype',np.dtype) == dtype
 
-def test_create_np_ndarray(h5_data):
+def test_create_np_ndarray(h5_data,compression_kwargs):
     """
     test proper creatoin and loading of numpy ndarray
     """
@@ -97,7 +97,7 @@ def test_create_np_ndarray(h5_data):
     # check that numpy array representing python utf8 string is properly 
     # stored as bytearray dataset and reloaded from
     np_array_data = np.array("im python string")
-    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_string_array")
+    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_string_array",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and iter(subitems) and not subitems
     assert bytes(h_dataset[()]) == np_array_data.tolist().encode("utf8")
     assert h_dataset.attrs["np_dtype"] == np_array_data.dtype.str.encode("ascii")
@@ -106,7 +106,7 @@ def test_create_np_ndarray(h5_data):
     # chekc that numpy array representing python bytes string is properly
     # stored as bytearray dataset and reloaded from
     np_array_data = np.array(b"im python bytes")
-    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_bytes_array")
+    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_bytes_array",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and iter(subitems) and not subitems
     assert h_dataset[()] == np_array_data.tolist()
     assert h_dataset.attrs["np_dtype"] == np_array_data.dtype.str.encode("ascii")
@@ -115,8 +115,12 @@ def test_create_np_ndarray(h5_data):
     # check that numpy array with dtype object representing list of various kinds
     # of objects is converted to list before storing and reloaded proprly from this
     # list representation
-    np_array_data = np.array([[NESTED_DICT], ('What is this?',), {1, 2, 3, 7, 1}])
-    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_list_object_array")
+
+    # NOTE: simplified as mixing items of varying length receives
+    # VisibleDeprecationWarning from newer numpy versions
+    #np_array_data = np.array([[NESTED_DICT], ('What is this?',), {1, 2, 3, 7, 1}])
+    np_array_data = np.array([NESTED_DICT])#, ('What is this?',), {1, 2, 3, 7, 1}])
+    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_list_object_array",**compression_kwargs)
     ndarray_container = load_numpy.NDArrayLikeContainer(h_dataset.attrs,b'ndarray',np_array_data.__class__)
     assert isinstance(h_dataset,h5.Group) and iter(subitems)
     assert h_dataset.attrs["np_dtype"] == np_array_data.dtype.str.encode("ascii")
@@ -130,7 +134,7 @@ def test_create_np_ndarray(h5_data):
     # is properly converted to list of strings and restored from its list
     # representation
     np_array_data = np.array(["1313e", "was", "maybe?", "here"])
-    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_list_of_strings_array")
+    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_list_of_strings_array",**compression_kwargs)
     ndarray_container = load_numpy.NDArrayLikeContainer(h_dataset.attrs,b'ndarray',np_array_data.__class__)
     assert isinstance(h_dataset,h5.Group) and iter(subitems)
     assert h_dataset.attrs["np_dtype"] == np_array_data.dtype.str.encode("ascii")
@@ -144,7 +148,7 @@ def test_create_np_ndarray(h5_data):
     # by ndarray.tolist method is properly stored according to type of object and
     # restored from this representation accordingly
     np_array_data = np.array(NESTED_DICT)
-    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_object_array")
+    h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_object_array",**compression_kwargs)
     ndarray_container = load_numpy.NDArrayLikeContainer(h_dataset.attrs,b'ndarray',np_array_data.__class__)
     ndarray_pickle_container = load_numpy.NDArrayLikeContainer(h_dataset.attrs,b'ndarray',np_array_data.__class__)
     assert isinstance(h_dataset,h5.Group) and iter(subitems)
@@ -174,7 +178,7 @@ def test_create_np_ndarray(h5_data):
     # just PendingDeprecationWarning
     with pytest.warns(PendingDeprecationWarning):
         np_array_data = np.matrix([[1, 2], [3, 4]])
-        h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_matrix")
+        h_dataset,subitems = load_numpy.create_np_array_dataset(np_array_data,h5_data,"numpy_matrix",**compression_kwargs)
         assert isinstance(h_dataset,h5.Dataset) and iter(subitems) and not subitems
         assert np.all(h_dataset[()] == np_array_data)
         assert h_dataset.attrs["np_dtype"] == np_array_data.dtype.str.encode("ascii")
@@ -183,14 +187,14 @@ def test_create_np_ndarray(h5_data):
         assert isinstance(np_loaded_array_data,np.matrix)
         assert np_loaded_array_data.shape == np_array_data.shape
     
-def test_create_np_masked_array(h5_data):
+def test_create_np_masked_array(h5_data,compression_kwargs):
     """
     test proper creation and loading of numpy.masked arrays
     """
 
     # check that simple masked array is properly stored and loaded
     masked_array = np.ma.array([1, 2, 3, 4], dtype='float32', mask=[0, 1, 0, 0])
-    h_datagroup,subitems = load_numpy.create_np_masked_array_dataset(masked_array, h5_data, "masked_array")
+    h_datagroup,subitems = load_numpy.create_np_masked_array_dataset(masked_array, h5_data, "masked_array",**compression_kwargs)
     masked_array_container = load_numpy.NDMaskedArrayContainer(h_datagroup.attrs,b'ndarray_masked',np.ma.array)
     assert isinstance(h_datagroup,h5.Group) and iter(subitems)
     assert h_datagroup.attrs["np_dtype"] == masked_array.dtype.str.encode("ascii")
@@ -222,13 +226,26 @@ def test_create_np_masked_array(h5_data):
 # %% MAIN SCRIPT
 if __name__ == "__main__":
     from _pytest.fixtures import FixtureRequest
-    for h5_root in h5_data(FixtureRequest(test_create_np_scalar)):
-        test_create_np_scalar(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_create_np_dtype)):
-        test_create_np_dtype(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_create_np_ndarray)):
-        test_create_np_ndarray(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_create_np_masked_array)):
-        test_create_np_masked_array(h5_root)
+    from hickle.tests.conftest import compression_kwargs
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_np_scalar),)
+    ):
+        test_create_np_scalar(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_np_dtype),)
+    ):
+        test_create_np_dtype(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_np_ndarray),)
+    ):
+        test_create_np_ndarray(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_np_masked_array),)
+    ):
+        test_create_np_masked_array(h5_root,keywords)
 
     
diff --git a/hickle/tests/test_05_load_scipy.py b/hickle/tests/test_05_load_scipy.py
index 5d13f943..536e60e9 100644
--- a/hickle/tests/test_05_load_scipy.py
+++ b/hickle/tests/test_05_load_scipy.py
@@ -37,7 +37,7 @@ def h5_data(request):
 
 # %% FUNCTION DEFINITIONS
 
-def test_create_sparse_dataset(h5_data):
+def test_create_sparse_dataset(h5_data,compression_kwargs):
     """
     test creation and loading of sparse matrix 
     """
@@ -55,7 +55,7 @@ def test_create_sparse_dataset(h5_data):
     sm3 = bsr_matrix((data, indices, indptr), shape=(6, 6))
 
     # check that csr type matrix is properly stored and loaded
-    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm1,h5_data,"csr_matrix")
+    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm1,h5_data,"csr_matrix",**compression_kwargs)
     assert isinstance(h_datagroup,h5.Group) and iter(subitems)
     seen_items = dict((key,False) for key in ("data",'indices','indptr','shape'))
     sparse_container = load_scipy.SparseMatrixContainer(h_datagroup.attrs,b'csr_matrix',csr_matrix)
@@ -67,7 +67,7 @@ def test_create_sparse_dataset(h5_data):
     assert np.all(reloaded.data == sm1.data) and reloaded.dtype == sm1.dtype and reloaded.shape == sm1.shape
 
     # check that csc type matrix is properly stored and loaded
-    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm2,h5_data,"csc_matrix")
+    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm2,h5_data,"csc_matrix",**compression_kwargs)
     assert isinstance(h_datagroup,h5.Group) and iter(subitems)
     seen_items = dict((key,False) for key in ("data",'indices','indptr','shape'))
     sparse_container = load_scipy.SparseMatrixContainer(h_datagroup.attrs,b'csc_matrix',csc_matrix)
@@ -79,7 +79,7 @@ def test_create_sparse_dataset(h5_data):
     assert np.all(reloaded.data == sm2.data) and reloaded.dtype == sm2.dtype and reloaded.shape == sm2.shape
 
     # check that bsr type matrix is properly stored and loaded
-    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm3,h5_data,"bsr_matrix")
+    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm3,h5_data,"bsr_matrix",**compression_kwargs)
     assert isinstance(h_datagroup,h5.Group) and iter(subitems)
     seen_items = dict((key,False) for key in ("data",'indices','indptr','shape'))
     sparse_container = load_scipy.SparseMatrixContainer(h_datagroup.attrs,b'bsr_matrix',bsr_matrix)
@@ -91,7 +91,7 @@ def test_create_sparse_dataset(h5_data):
     assert np.all(reloaded.data == sm3.data) and reloaded.dtype == sm3.dtype and reloaded.shape == sm3.shape
 
     # mimic hickle version 4.0.0 format to represent crs type matrix
-    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm1,h5_data,"csr_matrix_filtered")
+    h_datagroup,subitems = load_scipy.create_sparse_dataset(sm1,h5_data,"csr_matrix_filtered",**compression_kwargs)
     sparse_container = load_scipy.SparseMatrixContainer(h_datagroup.attrs,b'csr_matrix',load_scipy.return_first)
     for name,item,attrs,kwargs in subitems:
         h_dataset = h_datagroup.create_dataset(name,data=item)
@@ -126,5 +126,9 @@ def test_create_sparse_dataset(h5_data):
 # %% MAIN SCRIPT
 if __name__ == "__main__":
     from _pytest.fixtures import FixtureRequest
-    for h5_root in h5_data(FixtureRequest(test_create_sparse_dataset)):
-        test_create_sparse_dataset(h5_root)
+    from hickle.tests.conftest import compression_kwargs
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_sparse_dataset),)
+    ):
+        test_create_sparse_dataset(h5_root,keywords)
diff --git a/hickle/tests/test_06_load_astropy.py b/hickle/tests/test_06_load_astropy.py
index be7c5e66..a9304880 100644
--- a/hickle/tests/test_06_load_astropy.py
+++ b/hickle/tests/test_06_load_astropy.py
@@ -41,33 +41,33 @@ def h5_data(request):
     dummy_file.close()
 
 # %% FUNCTION DEFINITIONS
-def test_create_astropy_quantity(h5_data):
+def test_create_astropy_quantity(h5_data,compression_kwargs):
     """
     test proper storage and loading of astorpy quantities
     """
 
     for index,uu in enumerate(['m^3', 'm^3 / s', 'kg/pc']):
         a = Quantity(7, unit=uu)
-        h_dataset,subitems = load_astropy.create_astropy_quantity(a,h5_data,"quantity{}".format(index))
+        h_dataset,subitems = load_astropy.create_astropy_quantity(a,h5_data,"quantity{}".format(index),**compression_kwargs)
         assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
         assert h_dataset.attrs['unit'] == a.unit.to_string().encode("ascii") and h_dataset[()] == a.value
         reloaded = load_astropy.load_astropy_quantity_dataset(h_dataset,b'astropy_quantity',Quantity)
         assert reloaded == a and reloaded.unit == a.unit
         a *= a
-        h_dataset,subitems = load_astropy.create_astropy_quantity(a,h5_data,"quantity_sqr{}".format(index))
+        h_dataset,subitems = load_astropy.create_astropy_quantity(a,h5_data,"quantity_sqr{}".format(index),**compression_kwargs)
         assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
         assert h_dataset.attrs['unit'] == a.unit.to_string().encode("ascii") and h_dataset[()] == a.value
         reloaded = load_astropy.load_astropy_quantity_dataset(h_dataset,b'astropy_quantity',Quantity)
         assert reloaded == a and reloaded.unit == a.unit
 
 
-def test_create_astropy_constant(h5_data):
+def test_create_astropy_constant(h5_data,compression_kwargs):
 
     """
     test proper storage and loading of astropy constants
     """
 
-    h_dataset,subitems = load_astropy.create_astropy_constant(apc.G,h5_data,"apc_G")
+    h_dataset,subitems = load_astropy.create_astropy_constant(apc.G,h5_data,"apc_G",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset.attrs["unit"] == apc.G.unit.to_string().encode('ascii')
     assert h_dataset.attrs["abbrev"] == apc.G.abbrev.encode('ascii')
@@ -77,7 +77,7 @@ def test_create_astropy_constant(h5_data):
     reloaded = load_astropy.load_astropy_constant_dataset(h_dataset,b'astropy_constant',apc.G.__class__)
     assert reloaded == apc.G and reloaded.dtype == apc.G.dtype
 
-    h_dataset,subitems = load_astropy.create_astropy_constant(apc.cgs.e,h5_data,"apc_cgs_e")
+    h_dataset,subitems = load_astropy.create_astropy_constant(apc.cgs.e,h5_data,"apc_cgs_e",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset.attrs["unit"] == apc.cgs.e.unit.to_string().encode('ascii')
     assert h_dataset.attrs["abbrev"] == apc.cgs.e.abbrev.encode('ascii')
@@ -89,13 +89,13 @@ def test_create_astropy_constant(h5_data):
     assert reloaded == apc.cgs.e and reloaded.dtype == apc.cgs.e.dtype
 
 
-def test_astropy_table(h5_data):
+def test_astropy_table(h5_data,compression_kwargs):
     """
     test proper storage and loading of astropy table
     """
     t = Table([[1, 2], [3, 4]], names=('a', 'b'), meta={'name': 'test_thing'})
 
-    h_dataset,subitems = load_astropy.create_astropy_table(t,h5_data,"astropy_table")
+    h_dataset,subitems = load_astropy.create_astropy_table(t,h5_data,"astropy_table",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert np.all(h_dataset.attrs['colnames'] == [ cname.encode('ascii') for cname in t.colnames])
     for metakey,metavalue in t.meta.items():
@@ -107,19 +107,19 @@ def test_astropy_table(h5_data):
     assert np.allclose(t['b'].astype('float32'),reloaded['b'].astype('float32'))
 
 
-def test_astropy_quantity_array(h5_data):
+def test_astropy_quantity_array(h5_data,compression_kwargs):
     """
     tet proper storage and loading of array of astropy quantities 
     """
     a = Quantity([1, 2, 3], unit='m')
-    h_dataset,subitems = load_astropy.create_astropy_quantity(a,h5_data,"quantity_array")
+    h_dataset,subitems = load_astropy.create_astropy_quantity(a,h5_data,"quantity_array",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset.attrs['unit'] == a.unit.to_string().encode("ascii") and np.all(h_dataset[()] == a.value)
     reloaded = load_astropy.load_astropy_quantity_dataset(h_dataset,b'astropy_quantity',Quantity)
     assert np.all(reloaded == a) and reloaded.unit == a.unit
 
 
-def test_astropy_time_array(h5_data):
+def test_astropy_time_array(h5_data,compression_kwargs):
     """
     test proper storage and loading of astropy time representations
     """
@@ -127,7 +127,7 @@ def test_astropy_time_array(h5_data):
     times = ['1999-01-01T00:00:00.123456789', '2010-01-01T00:00:00']
     t1 = Time(times, format='isot', scale='utc')
 
-    h_dataset,subitems = load_astropy.create_astropy_time(t1,h5_data,'time1')
+    h_dataset,subitems = load_astropy.create_astropy_time(t1,h5_data,'time1',**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset.attrs['format'] == str(t1.format).encode('ascii')
     assert h_dataset.attrs['scale'] == str(t1.scale).encode('ascii')
@@ -149,7 +149,7 @@ def test_astropy_time_array(h5_data):
 
     times = [58264, 58265, 58266]
     t1 = Time(times, format='mjd', scale='utc')
-    h_dataset,subitems = load_astropy.create_astropy_time(t1,h5_data,'time2')
+    h_dataset,subitems = load_astropy.create_astropy_time(t1,h5_data,'time2',**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset.attrs['format'] == str(t1.format).encode('ascii')
     assert h_dataset.attrs['scale'] == str(t1.scale).encode('ascii')
@@ -162,14 +162,14 @@ def test_astropy_time_array(h5_data):
         assert reloaded.value[index] == t1.value[index]
 
 
-def test_astropy_angle(h5_data):
+def test_astropy_angle(h5_data,compression_kwargs):
     """
     test proper storage of astropy angles
     """
 
     for index,uu in enumerate(['radian', 'degree']):
         a = Angle(1.02, unit=uu)
-        h_dataset,subitems = load_astropy.create_astropy_angle(a,h5_data,"angle_{}".format(uu))
+        h_dataset,subitems = load_astropy.create_astropy_angle(a,h5_data,"angle_{}".format(uu),**compression_kwargs)
         assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
         assert h_dataset.attrs['unit'] == a.unit.to_string().encode('ascii')
         assert h_dataset[()] == a.value
@@ -177,19 +177,19 @@ def test_astropy_angle(h5_data):
         assert reloaded == a and reloaded.unit == a.unit
 
 
-def test_astropy_angle_array(h5_data):
+def test_astropy_angle_array(h5_data,compression_kwargs):
     """
     test proper storage and loading of arrays of astropy angles
     """
     a = Angle([1, 2, 3], unit='degree')
-    h_dataset,subitems = load_astropy.create_astropy_angle(a,h5_data,"angle_array")
+    h_dataset,subitems = load_astropy.create_astropy_angle(a,h5_data,"angle_array",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset.attrs['unit'] == a.unit.to_string().encode('ascii')
     assert np.allclose(h_dataset[()] , a.value )
     reloaded = load_astropy.load_astropy_angle_dataset(h_dataset,b'astropy_angle',a.__class__)
     assert np.all(reloaded ==  a) and reloaded.unit == a.unit
 
-def test_astropy_skycoord(h5_data):
+def test_astropy_skycoord(h5_data,compression_kwargs):
     """
     test proper storage and loading of astropy sky coordinates
     """
@@ -197,7 +197,7 @@ def test_astropy_skycoord(h5_data):
     ra = Angle('1d20m', unit='degree')
     dec = Angle('33d0m0s', unit='degree')
     radec = SkyCoord(ra, dec)
-    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_1")
+    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_1",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset[()][...,0] == radec.data.lon.value
     assert h_dataset[()][...,1] == radec.data.lat.value
@@ -210,7 +210,7 @@ def test_astropy_skycoord(h5_data):
     ra = Angle('1d20m', unit='hourangle')
     dec = Angle('33d0m0s', unit='degree')
     radec = SkyCoord(ra, dec)
-    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_2")
+    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_2",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert h_dataset[()][...,0] == radec.data.lon.value
     assert h_dataset[()][...,1] == radec.data.lat.value
@@ -220,7 +220,7 @@ def test_astropy_skycoord(h5_data):
     assert reloaded.ra.value == radec.ra.value
     assert reloaded.dec.value == radec.dec.value
 
-def test_astropy_skycoord_array(h5_data):
+def test_astropy_skycoord_array(h5_data,compression_kwargs):
     """
     test proper storage and loading of astropy sky coordinates
     """
@@ -228,7 +228,7 @@ def test_astropy_skycoord_array(h5_data):
     ra = Angle(['1d20m', '0d21m'], unit='degree')
     dec = Angle(['33d0m0s', '-33d01m'], unit='degree')
     radec = SkyCoord(ra, dec)
-    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_1")
+    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_1",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert np.allclose(h_dataset[()][...,0],radec.data.lon.value)
     assert np.allclose(h_dataset[()][...,1],radec.data.lat.value)
@@ -241,7 +241,7 @@ def test_astropy_skycoord_array(h5_data):
     ra = Angle([['1d20m', '0d21m'], ['1d20m', '0d21m']], unit='hourangle')
     dec = Angle([['33d0m0s', '33d01m'], ['33d0m0s', '33d01m']], unit='degree')
     radec = SkyCoord(ra, dec)
-    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_2")
+    h_dataset,subitems = load_astropy.create_astropy_skycoord(radec,h5_data,"astropy_skycoord_2",**compression_kwargs)
     assert isinstance(h_dataset,h5.Dataset) and not subitems and iter(subitems)
     assert np.allclose(h_dataset[()][...,0],radec.data.lon.value)
     assert np.allclose(h_dataset[()][...,1],radec.data.lat.value)
@@ -256,21 +256,49 @@ def test_astropy_skycoord_array(h5_data):
 # %% MAIN SCRIPT
 if __name__ == "__main__":
     from _pytest.fixtures import FixtureRequest
-    for h5_root in h5_data(FixtureRequest(test_create_astropy_quantity)):
-        test_create_astropy_quantity(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_create_astropy_constant)):
-        test_create_astropy_constant(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_table)):
-        test_astropy_table(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_quantity_array)):
-        test_astropy_quantity_array(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_time_array)):
-        test_astropy_time_array(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_angle)):
-        test_astropy_angle(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_angle_array)):
-        test_astropy_angle_array(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_skycoord)):
-        test_astropy_skycoord(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_astropy_skycoord_array)):
-        test_astropy_skycoord_array(h5_root)
+    from hickle.tests.conftest import compression_kwargs
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_astropy_quantity),)
+    ):
+        test_create_astropy_quantity(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_create_astropy_constant),)
+    ):
+        test_create_astropy_constant(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_table),)
+    ):
+        test_astropy_table(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_quantity_array),)
+    ):
+        test_astropy_quantity_array(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_time_array),)
+    ):
+        test_astropy_time_array(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_angle),)
+    ):
+        test_astropy_angle(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_angle_array),)
+    ):
+        test_astropy_angle_array(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_skycoord),)
+    ):
+        test_astropy_skycoord(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_astropy_skycoord_array),)
+    ):
+        test_astropy_skycoord_array(h5_root,keywords)
diff --git a/hickle/tests/test_99_hickle_core.py b/hickle/tests/test_99_hickle_core.py
index 8fd9ede0..366b572d 100644
--- a/hickle/tests/test_99_hickle_core.py
+++ b/hickle/tests/test_99_hickle_core.py
@@ -54,7 +54,7 @@ def test_file_name(request):
 
 # %% FUNCTION DEFINITIONS
         
-def test_recursive_dump(h5_data):
+def test_recursive_dump(h5_data,compression_kwargs):
     """
     test _dump function and that it properly calls itself recursively 
     """
@@ -64,7 +64,7 @@ def test_recursive_dump(h5_data):
     data = simple_list = [1,2,3,4]
     with lookup.ReferenceManager.create_manager(h5_data) as memo:
         with lookup.LoaderManager.create_manager(h5_data) as loader:
-            hickle._dump(data, h5_data, "simple_list",memo,loader)
+            hickle._dump(data, h5_data, "simple_list",memo,loader,**compression_kwargs)
             dumped_data = h5_data["simple_list"]
             assert memo.resolve_type(dumped_data) == (data.__class__,b'list',False)
             assert np.all(dumped_data[()] == simple_list)
@@ -76,7 +76,7 @@ def test_recursive_dump(h5_data):
                 '12':12,
                 (1,2,3):'hallo'
             }
-            hickle._dump(data, h5_data, "some_dict",memo,loader)
+            hickle._dump(data, h5_data, "some_dict",memo,loader,**compression_kwargs)
             dumped_data = h5_data["some_dict"]
             assert memo.resolve_type(dumped_data) == (data.__class__,b'dict',True)
         
@@ -118,13 +118,13 @@ def fail_create_dict(py_obj,h_group,name,**kwargs):
             loader.types_dict.maps.insert(0,{dict:(fail_create_dict,*loader.types_dict[dict][1:])})
             memo_backup = memo.pop(id(data),None)
             with pytest.warns(lookup.SerializedWarning):
-                hickle._dump(data, h5_data, "pickled_dict",memo,loader)
+                hickle._dump(data, h5_data, "pickled_dict",memo,loader,**compression_kwargs)
             dumped_data = h5_data["pickled_dict"]
             assert bytes(dumped_data[()]) == pickle.dumps(data)
             loader.types_dict.maps.pop(0)
             memo[id(data)] = memo_backup
     
-def test_recursive_load(h5_data):
+def test_recursive_load(h5_data,compression_kwargs):
     """
     test _load function and that it properly calls itself recursively 
     """
@@ -135,7 +135,7 @@ def test_recursive_load(h5_data):
     data_name = "the_answer"
     with lookup.ReferenceManager.create_manager(h5_data) as memo:
         with lookup.LoaderManager.create_manager(h5_data) as loader:
-            hickle._dump(data, h5_data, data_name,memo,loader)
+            hickle._dump(data, h5_data, data_name,memo,loader,**compression_kwargs)
             py_container = hickle.RootContainer(h5_data.attrs,b'hickle_root',hickle.RootContainer)
             hickle._load(py_container, data_name, h5_data[data_name],memo,loader)
             assert py_container.convert() == data
@@ -143,7 +143,7 @@ def test_recursive_load(h5_data):
             # check that dict object is properly restored on load from corresponding group
             data = {'question':None,'answer':42}
             data_name = "not_formulated"
-            hickle._dump(data, h5_data, data_name,memo,loader)
+            hickle._dump(data, h5_data, data_name,memo,loader,**compression_kwargs)
             py_container = hickle.RootContainer(h5_data.attrs,b'hickle_root',hickle.RootContainer)
             hickle._load(py_container, data_name, h5_data[data_name],memo,loader)
             assert py_container.convert() == data
@@ -158,7 +158,7 @@ def fail_create_dict(py_obj,h_group,name,**kwargs):
             data_name = "pickled_dict"
             memo_backup = memo.pop(id(data),None)
             with pytest.warns(lookup.SerializedWarning):
-                hickle._dump(data, h5_data, data_name,memo,loader)
+                hickle._dump(data, h5_data, data_name,memo,loader,**compression_kwargs)
             hickle._load(py_container, data_name, h5_data[data_name],memo,loader)
             assert py_container.convert() == data
             loader.types_dict.maps.pop(0)
@@ -166,59 +166,59 @@ def fail_create_dict(py_obj,h_group,name,**kwargs):
 
 # %% ISSUE RELATED TESTS
 
-def test_invalid_file():
+def test_invalid_file(compression_kwargs):
     """ Test if trying to use a non-file object fails. """
 
     with pytest.raises(hickle.FileError):
-        dump('test', ())
+        dump('test', (),**compression_kwargs)
 
 
-def test_binary_file(test_file_name):
+def test_binary_file(test_file_name,compression_kwargs):
     """ Test if using a binary file works
 
     https://github.com/telegraphic/hickle/issues/123"""
 
     filename = test_file_name.replace(".hkl",".hdf5")
     with open(filename, "w") as f:
-        with pytest.raises(helpers.FileError):
-            hickle.dump(None, f)
+        with pytest.raises(hickle.FileError):
+            hickle.dump(None, f,**compression_kwargs)
     with open(filename, "w+") as f:
-        with pytest.raises(helpers.FileError):
-            hickle.dump(None, f)
+        with pytest.raises(hickle.FileError):
+            hickle.dump(None, f,**compression_kwargs)
 
     with open(filename, "wb") as f:
-        with pytest.raises(helpers.FileError):
-            hickle.dump(None, f)
+        with pytest.raises(hickle.FileError):
+            hickle.dump(None, f,**compression_kwargs)
 
     with open(filename, "w+b") as f:
-        hickle.dump(None, f)
+        hickle.dump(None, f,**compression_kwargs)
 
 
-def test_file_open_close(test_file_name,h5_data):
+def test_file_open_close(test_file_name,h5_data,compression_kwargs):
     """ https://github.com/telegraphic/hickle/issues/20 """
     import h5py
     f = h5py.File(test_file_name.replace(".hkl",".hdf"), 'w')
     a = np.arange(5)
 
-    dump(a, test_file_name)
-    dump(a, test_file_name)
+    dump(a, test_file_name,**compression_kwargs)
+    dump(a, test_file_name,**compression_kwargs)
 
-    dump(a, f, mode='w')
+    dump(a, f, mode='w',**compression_kwargs)
     f.close()
     with pytest.raises(hickle.ClosedFileError):
-        dump(a, f, mode='w')
+        dump(a, f, mode='w',**compression_kwargs)
     h5_data.create_dataset('nothing',data=[])
     with pytest.raises(ValueError,match = r"Unable\s+to\s+create\s+group\s+\(name\s+already\s+exists\)"):
-        dump(a,h5_data.file,path="/root_group")
+        dump(a,h5_data.file,path="/root_group",**compression_kwargs)
 
 
-def test_hdf5_group(test_file_name):
+def test_hdf5_group(test_file_name,compression_kwargs):
     import h5py
     hdf5_filename = test_file_name.replace(".hkl",".hdf5")
     file = h5py.File(hdf5_filename, 'w')
     group = file.create_group('test_group')
     a = np.arange(5)
-    dump(a, group)
+    dump(a, group,**compression_kwargs)
     file.close()
 
     a_hkl = load(hdf5_filename, path='/test_group')
@@ -228,7 +228,7 @@ def test_hdf5_group(test_file_name):
     group = file.create_group('test_group2')
     b = np.arange(8)
 
-    dump(b, group, path='deeper/and_deeper')
+    dump(b, group, path='deeper/and_deeper',**compression_kwargs)
     file.close()
 
     with pytest.raises(ValueError):
@@ -243,7 +243,7 @@ def test_hdf5_group(test_file_name):
 
 
 
-def test_with_open_file(test_file_name):
+def test_with_open_file(test_file_name,compression_kwargs):
     """
     Testing dumping and loading to an open file
 
@@ -255,10 +255,10 @@ def test_with_open_file(test_file_name):
     arr = np.array([1])
 
     with h5py.File(test_file_name, 'w') as file:
-        dump(lst, file, path='/lst')
-        dump(tpl, file, path='/tpl')
-        dump(dct, file, path='/dct')
-        dump(arr, file, path='/arr')
+        dump(lst, file, path='/lst',**compression_kwargs)
+        dump(tpl, file, path='/tpl',**compression_kwargs)
+        dump(dct, file, path='/dct',**compression_kwargs)
+        dump(arr, file, path='/arr',**compression_kwargs)
 
     with h5py.File(test_file_name, 'r') as file:
         assert load(file, '/lst') == lst
@@ -267,7 +267,7 @@ def test_with_open_file(test_file_name):
         assert load(file, '/arr') == arr
 
 
-def test_load(test_file_name):
+def test_load(test_file_name,compression_kwargs):
     a = set([1, 2, 3, 4])
     b = set([5, 6, 7, 8])
     c = set([9, 10, 11, 12])
@@ -277,7 +277,7 @@ def test_load(test_file_name):
 
     print("Original:")
     pprint(z)
-    dump(z, test_file_name, mode='w')
+    dump(z, test_file_name, mode='w',**compression_kwargs)
 
     print("\nReconstructed:")
     z = load(test_file_name)
@@ -286,7 +286,7 @@ def test_load(test_file_name):
 
 
 
-def test_multi_hickle(test_file_name):
+def test_multi_hickle(test_file_name,compression_kwargs):
     """ Dumping to and loading from the same file several times
 
     https://github.com/telegraphic/hickle/issues/20"""
@@ -295,10 +295,10 @@ def test_multi_hickle(test_file_name):
 
     if os.path.exists(test_file_name):
         os.remove(test_file_name)
-    dump(a, test_file_name, path="/test", mode="w")
-    dump(a, test_file_name, path="/test2", mode="r+")
-    dump(a, test_file_name, path="/test3", mode="r+")
-    dump(a, test_file_name, path="/test4", mode="r+")
+    dump(a, test_file_name, path="/test", mode="w",**compression_kwargs)
+    dump(a, test_file_name, path="/test2", mode="r+",**compression_kwargs)
+    dump(a, test_file_name, path="/test3", mode="r+",**compression_kwargs)
+    dump(a, test_file_name, path="/test4", mode="r+",**compression_kwargs)
 
     load(test_file_name, path="/test")
     load(test_file_name, path="/test2")
@@ -306,7 +306,7 @@ def test_multi_hickle(test_file_name):
     load(test_file_name, path="/test4")
 
 
-def test_improper_attrs(test_file_name):
+def test_improper_attrs(test_file_name,compression_kwargs):
     """
     test for proper reporting missing mandatory attributes for the various
     supported file versions
@@ -315,7 +315,7 @@ def test_improper_attrs(test_file_name):
     # check that missing attributes which disallow to identify
     # hickle version are reported
     data = "my name? Ha I'm Nobody"
-    dump(data,test_file_name)
+    dump(data,test_file_name,**compression_kwargs)
     manipulated = h5py.File(test_file_name,"r+")
     root_group = manipulated.get('/')
     root_group.attrs["VERSION"] = root_group.attrs["HICKLE_VERSION"]
@@ -333,33 +333,53 @@ def test_improper_attrs(test_file_name):
 if __name__ == '__main__':
     """ Some tests and examples """
     from _pytest.fixtures import FixtureRequest
+    from hickle.tests.conftest import compression_kwargs
 
-    for h5_root,filename in (
-        ( h5_data(request),test_file_name(request) )
-        for request in (FixtureRequest(test_file_opener),)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_recursive_dump),)
     ):
-        test_file_opener(h5_root,filename)
-    for h5_root in h5_data(FixtureRequest(test_recursive_dump)):
-        test_recursive_dump(h5_root)
-    for h5_root in h5_data(FixtureRequest(test_recursive_load)):
-        test_recursive_load(h5_root)
-    test_invalid_file()
-    for filename in test_file_name(FixtureRequest(test_binary_file)):
-        test_binary_file(filename)
-    for h5_root,filename in (
-        ( h5_data(request),test_file_name(request) )
+        test_recursive_dump(h5_root,keywords)
+    for h5_root,keywords in (
+        ( h5_data(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_recursive_load),)
+    ):
+        test_recursive_load(h5_root,keywords)
+    for keywords in compression_kwargs(FixtureRequest(test_recursive_dump)):
+        test_invalid_file(keywords)
+    for filename,keywords in (
+        ( test_file_name(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_binary_file),)
+    ):
+        test_binary_file(filename,keywords)
+    for h5_root,filename,keywords in (
+        ( h5_data(request),test_file_name(request),compression_kwargs(request) )
         for request in (FixtureRequest(test_file_open_close),)
     ):
-        test_file_open_close(h5_root,filename)
-    for filename in test_file_name(FixtureRequest(test_hdf5_group)):
-        test_hdf5_group(filename)
-    for filename in test_file_name(FixtureRequest(test_with_open_file)):
-        test_with_open_file(filename)
-
-    for filename in test_file_name(FixtureRequest(test_load)):
-        test_load(filename)
-    for filename in test_file_name(FixtureRequest(test_multi_hickle)):
-        test_multi_hickle(filename)
-    for filename in test_file_name(FixtureRequest(test_improper_attrs)):
-        test_improper_attrs(filename)
+        test_file_open_close(h5_root,filename,keywords)
+    for filename,keywords in (
+        ( test_file_name(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_hdf5_group),)
+    ):
+        test_hdf5_group(filename,keywords)
+    for filename,keywords in (
+        ( test_file_name(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_with_open_file),)
+    ):
+        test_with_open_file(filename,keywords)
+    for filename,keywords in (
+        ( test_file_name(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_load),)
+    ):
+        test_load(filename,keywords)
+    for filename,keywords in (
+        ( test_file_name(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_multi_hickle),)
+    ):
+        test_multi_hickle(filename,keywords)
+    for filename,keywords in (
+        ( test_file_name(request),compression_kwargs(request) )
+        for request in (FixtureRequest(test_improper_attrs),)
+    ):
+        test_improper_attrs(filename,keywords)
 
diff --git a/hickle/tests/test_hickle.py b/hickle/tests/test_hickle.py
index 20827902..946e5115 100644
--- a/hickle/tests/test_hickle.py
+++ b/hickle/tests/test_hickle.py
@@ -137,7 +137,7 @@ def test_invalid_file():
         dump('test', ())
 
 
-def test_state_obj(monkeypatch,test_file_name):
+def test_state_obj(monkeypatch,test_file_name,compression_kwargs):
     """ Dumping and loading a class object with pickle states
 
     https://github.com/telegraphic/hickle/issues/125"""
@@ -148,63 +148,63 @@ def test_state_obj(monkeypatch,test_file_name):
         mode = 'w'
         obj = with_state()
         with pytest.warns(lookup.SerializedWarning):
-            dump(obj, test_file_name, mode)
+            dump(obj, test_file_name, mode,**compression_kwargs)
         monkey.setattr(pickle,'loads',hide_from_hickle)
         obj_hkl = load(test_file_name)
         assert isinstance(obj,obj_hkl.__class__) or isinstance(obj_hkl,obj.__class__)
         assert np.allclose(obj[1], obj_hkl[1])
 
 
-def test_local_func(test_file_name):
+def test_local_func(test_file_name,compression_kwargs):
     """ Dumping and loading a local function
 
     https://github.com/telegraphic/hickle/issues/119"""
 
     mode =  'w'
     with pytest.warns(lookup.SerializedWarning):
-        dump(func, test_file_name, mode)
+        dump(func, test_file_name, mode,**compression_kwargs)
     func_hkl = load(test_file_name)
     assert isinstance(func,func_hkl.__class__) or isinstance(func_hkl,func.__class__)
     assert func(1, 2) == func_hkl(1, 2)
 
 
-def test_non_empty_group(test_file_name):
+def test_non_empty_group(test_file_name,compression_kwargs):
     """ Test if attempting to dump to a group with data fails """
 
-    hickle.dump(None, test_file_name)
+    hickle.dump(None, test_file_name,**compression_kwargs)
     with pytest.raises(ValueError):
-        dump(None, test_file_name, 'r+')
+        dump(None, test_file_name, 'r+',**compression_kwargs)
 
 
-def test_string(test_file_name):
+def test_string(test_file_name,compression_kwargs):
     """ Dumping and loading a string """
     mode = 'w'
     string_obj = "The quick brown fox jumps over the lazy dog"
-    dump(string_obj, test_file_name, mode)
+    dump(string_obj, test_file_name, mode,**compression_kwargs)
     string_hkl = load(test_file_name)
     assert isinstance(string_hkl, str)
     assert string_obj == string_hkl
 
 
-def test_65bit_int(test_file_name):
+def test_65bit_int(test_file_name,compression_kwargs):
     """ Dumping and loading an integer with arbitrary precision
 
     https://github.com/telegraphic/hickle/issues/113"""
     i = 2**65-1
-    dump(i, test_file_name)
+    dump(i, test_file_name,**compression_kwargs)
     i_hkl = load(test_file_name)
     assert i == i_hkl
 
     j = -2**63-1
-    dump(j, test_file_name)
+    dump(j, test_file_name,**compression_kwargs)
     j_hkl = load(test_file_name)
     assert j == j_hkl
 
-def test_list(test_file_name):
+def test_list(test_file_name,compression_kwargs):
     """ Dumping and loading a list """
     filename, mode = 'test_list.h5', 'w'
     list_obj = [1, 2, 3, 4, 5]
-    dump(list_obj, test_file_name, mode=mode)
+    dump(list_obj, test_file_name, mode=mode,**compression_kwargs)
     list_hkl = load(test_file_name)
     try:
         assert isinstance(list_hkl, list)
@@ -220,11 +220,11 @@ def test_list(test_file_name):
         raise
 
 
-def test_set(test_file_name)    :
+def test_set(test_file_name,compression_kwargs)    :
     """ Dumping and loading a list """
     mode = 'w'
     list_obj = set([1, 0, 3, 4.5, 11.2])
-    dump(list_obj, test_file_name, mode)
+    dump(list_obj, test_file_name, mode,**compression_kwargs)
     list_hkl = load(test_file_name)
     try:
         assert isinstance(list_hkl, set)
@@ -235,14 +235,14 @@ def test_set(test_file_name)    :
         raise
 
 
-def test_numpy(test_file_name):
+def test_numpy(test_file_name,compression_kwargs):
     """ Dumping and loading numpy array """
     mode = 'w'
     dtypes = ['float32', 'float64', 'complex64', 'complex128']
 
     for dt in dtypes:
         array_obj = np.ones(8, dtype=dt)
-        dump(array_obj, test_file_name, mode)
+        dump(array_obj, test_file_name, mode,**compression_kwargs)
         array_hkl = load(test_file_name)
     try:
         assert array_hkl.dtype == array_obj.dtype
@@ -253,12 +253,12 @@ def test_numpy(test_file_name):
         raise
 
 
-def test_masked(test_file_name):
+def test_masked(test_file_name,compression_kwargs):
     """ Test masked numpy array """
     mode = 'w'
     a = np.ma.array([1, 2, 3, 4], dtype='float32', mask=[0, 1, 0, 0])
 
-    dump(a, test_file_name, mode)
+    dump(a, test_file_name, mode,**compression_kwargs)
     a_hkl = load(test_file_name)
 
     try:
@@ -270,45 +270,48 @@ def test_masked(test_file_name):
         raise
 
 
-def test_object_numpy(test_file_name):
+def test_object_numpy(test_file_name,compression_kwargs):
     """ Dumping and loading a NumPy array containing non-NumPy objects.
 
     https://github.com/telegraphic/hickle/issues/90"""
 
-    arr = np.array([[NESTED_DICT], ('What is this?',), {1, 2, 3, 7, 1}])
-    dump(arr, test_file_name)
+    # VisibleDeprecationWarning from newer numpy versions
+    #np_array_data = np.array([[NESTED_DICT], ('What is this?',), {1, 2, 3, 7, 1}])
+    arr = np.array([NESTED_DICT])#, ('What is this?',), {1, 2, 3, 7, 1}])
+    dump(arr, test_file_name,**compression_kwargs)
     arr_hkl = load(test_file_name)
     assert np.all(arr == arr_hkl)
 
     arr2 = np.array(NESTED_DICT)
-    dump(arr2, test_file_name)
+    dump(arr2, test_file_name,**compression_kwargs)
     arr_hkl2 = load(test_file_name)
     assert np.all(arr2 == arr_hkl2)
 
 
-def test_string_numpy(test_file_name):
+def test_string_numpy(test_file_name,compression_kwargs):
     """ Dumping and loading NumPy arrays containing Python 3 strings. """
 
     arr = np.array(["1313e", "was", "maybe?", "here"])
-    dump(arr, test_file_name)
+    dump(arr, test_file_name,**compression_kwargs)
     arr_hkl = load(test_file_name)
     assert np.all(arr == arr_hkl)
 
 
-def test_list_object_numpy(test_file_name):
+def test_list_object_numpy(test_file_name,compression_kwargs):
     """ Dumping and loading a list of NumPy arrays with objects.
 
     https://github.com/telegraphic/hickle/issues/90"""
 
-    lst = [np.array(NESTED_DICT), np.array([('What is this?',),
-                                            {1, 2, 3, 7, 1}])]
-    dump(lst, test_file_name)
+    # VisibleDeprecationWarning from newer numpy versions
+    lst = [np.array(NESTED_DICT)]#, np.array([('What is this?',),
+                                 #           {1, 2, 3, 7, 1}])]
+    dump(lst, test_file_name,**compression_kwargs)
     lst_hkl = load(test_file_name)
     assert np.all(lst[0] == lst_hkl[0])
-    assert np.all(lst[1] == lst_hkl[1])
+    #assert np.all(lst[1] == lst_hkl[1])
 
 
-def test_dict(test_file_name):
+def test_dict(test_file_name,compression_kwargs):
     """ Test dictionary dumping and loading """
     mode = 'w'
 
@@ -321,7 +324,7 @@ def test_dict(test_file_name):
         'narr': np.array([1, 2, 3]),
     }
 
-    dump(dd, test_file_name, mode)
+    dump(dd, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
 
     for k in dd.keys():
@@ -341,14 +344,14 @@ def test_dict(test_file_name):
             raise
 
 
-def test_odict(test_file_name):
+def test_odict(test_file_name,compression_kwargs):
     """ Test ordered dictionary dumping and loading
 
     https://github.com/telegraphic/hickle/issues/65"""
     mode = 'w'
 
     od = odict(((3, [3, 0.1]), (7, [5, 0.1]), (5, [3, 0.1])))
-    dump(od, test_file_name, mode)
+    dump(od, test_file_name, mode,**compression_kwargs)
     od_hkl = load(test_file_name)
 
     assert od.keys() == od_hkl.keys()
@@ -357,16 +360,23 @@ def test_odict(test_file_name):
         assert od_item == od_hkl_item
 
 
-def test_empty_dict(test_file_name):
+def test_empty_dict(test_file_name,compression_kwargs):
     """ Test empty dictionary dumping and loading
 
     https://github.com/telegraphic/hickle/issues/91"""
     mode = 'w'
 
-    dump({}, test_file_name, mode)
+    dump({}, test_file_name, mode,**compression_kwargs)
     assert load(test_file_name) == {}
 
 
+
+# TODO consider converting to parameterized test
+#      or enable implicit parameterizing of all tests
+#      though compression_kwargs fixture providing
+#      various combinations of compression and chunking
+#      related keywords
+@pytest.mark.no_compression
 def test_compression(test_file_name):
     """ Test compression on datasets"""
 
@@ -390,7 +400,7 @@ def test_compression(test_file_name):
         raise
 
 
-def test_dict_int_key(test_file_name):
+def test_dict_int_key(test_file_name,compression_kwargs):
     """ Test for dictionaries with integer keys """
     mode = 'w'
 
@@ -399,17 +409,17 @@ def test_dict_int_key(test_file_name):
         1: "test2"
     }
 
-    dump(dd, test_file_name, mode)
+    dump(dd, test_file_name, mode,**compression_kwargs)
     load(test_file_name)
 
 
-def test_dict_nested(test_file_name):
+def test_dict_nested(test_file_name,compression_kwargs):
     """ Test for dictionaries with integer keys """
     mode = 'w'
 
     dd = NESTED_DICT
 
-    dump(dd, test_file_name, mode)
+    dump(dd, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
 
     ll_hkl = dd_hkl["level1_3"]["level2_1"]["level3_1"]
@@ -417,7 +427,7 @@ def test_dict_nested(test_file_name):
     assert ll == ll_hkl
 
 
-def test_masked_dict(test_file_name):
+def test_masked_dict(test_file_name,compression_kwargs):
     """ Test dictionaries with masked arrays """
 
     filename, mode = 'test.h5', 'w'
@@ -427,7 +437,7 @@ def test_masked_dict(test_file_name):
         "data2": np.array([1, 2, 3, 4, 5])
     }
 
-    dump(dd, test_file_name, mode)
+    dump(dd, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
 
     for k in dd.keys():
@@ -451,7 +461,7 @@ def test_masked_dict(test_file_name):
             raise
 
 
-def test_np_float(test_file_name):
+def test_np_float(test_file_name,compression_kwargs):
     """ Test for singular np dtypes """
     mode = 'w'
 
@@ -463,7 +473,7 @@ def test_np_float(test_file_name):
     for dt in dtype_list:
 
         dd = dt(1)
-        dump(dd, test_file_name, mode)
+        dump(dd, test_file_name, mode,**compression_kwargs)
         dd_hkl = load(test_file_name)
         assert dd == dd_hkl
         assert dd.dtype == dd_hkl.dtype
@@ -471,7 +481,7 @@ def test_np_float(test_file_name):
     dd = {}
     for dt in dtype_list:
         dd[str(dt)] = dt(1.0)
-    dump(dd, test_file_name, mode)
+    dump(dd, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
 
     print(dd)
@@ -479,6 +489,12 @@ def test_np_float(test_file_name):
         assert dd[str(dt)] == dd_hkl[str(dt)]
 
 
+# TODO consider converting to parameterized test
+#      or enable implicit parameterizing of all tests
+#      though compression_kwargs fixture providing
+#      various combinations of compression and chunking
+#      related keywords
+@pytest.mark.no_compression
 def test_comp_kwargs(test_file_name):
     """ Test compression with some kwargs for shuffle and chunking """
 
@@ -508,7 +524,7 @@ def test_comp_kwargs(test_file_name):
                         load(test_file_name)
 
 
-def test_list_numpy(test_file_name):
+def test_list_numpy(test_file_name,compression_kwargs):
     """ Test converting a list of numpy arrays """
 
     mode = 'w'
@@ -517,7 +533,7 @@ def test_list_numpy(test_file_name):
     b = np.zeros(1000)
     c = [a, b]
 
-    dump(c, test_file_name, mode)
+    dump(c, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
 
     print(dd_hkl)
@@ -526,7 +542,7 @@ def test_list_numpy(test_file_name):
     assert isinstance(dd_hkl[0], np.ndarray)
 
 
-def test_tuple_numpy(test_file_name):
+def test_tuple_numpy(test_file_name,compression_kwargs):
     """ Test converting a list of numpy arrays """
 
     mode = 'w'
@@ -535,7 +551,7 @@ def test_tuple_numpy(test_file_name):
     b = np.zeros(1000)
     c = (a, b, a)
 
-    dump(c, test_file_name, mode)
+    dump(c, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
 
     print(dd_hkl)
@@ -544,23 +560,23 @@ def test_tuple_numpy(test_file_name):
     assert isinstance(dd_hkl[0], np.ndarray)
 
 
-def test_numpy_dtype(test_file_name):
+def test_numpy_dtype(test_file_name,compression_kwargs):
     """ Dumping and loading a NumPy dtype """
 
     dtype = np.dtype('float16')
-    dump(dtype, test_file_name)
+    dump(dtype, test_file_name,**compression_kwargs)
     dtype_hkl = load(test_file_name)
     assert dtype == dtype_hkl
 
 
-def test_none(test_file_name):
+def test_none(test_file_name,compression_kwargs):
     """ Test None type hickling """
 
     mode = 'w'
 
     a = None
 
-    dump(a, test_file_name, mode)
+    dump(a, test_file_name, mode,**compression_kwargs)
     dd_hkl = load(test_file_name)
     print(a)
     print(dd_hkl)
@@ -568,10 +584,10 @@ def test_none(test_file_name):
     assert isinstance(dd_hkl, type(None))
 
 
-def test_list_order(test_file_name):
+def test_list_order(test_file_name,compression_kwargs):
     """ https://github.com/telegraphic/hickle/issues/26 """
     d = [np.arange(n + 1) for n in range(20)]
-    dump(d, test_file_name)
+    dump(d, test_file_name,**compression_kwargs)
     d_hkl = load(test_file_name)
 
     try:
@@ -584,12 +600,12 @@ def test_list_order(test_file_name):
         raise
 
 
-def test_embedded_array(test_file_name):
+def test_embedded_array(test_file_name,compression_kwargs):
     """ See https://github.com/telegraphic/hickle/issues/24 """
 
     d_orig = [[np.array([10., 20.]), np.array([10, 20, 30])],
               [np.array([10, 2]), np.array([1.])]]
-    dump(d_orig, test_file_name)
+    dump(d_orig, test_file_name,**compression_kwargs)
     d_hkl = load(test_file_name)
 
     for ii, xx in enumerate(d_orig):
@@ -620,76 +636,76 @@ def generate_nested():
     z = {'a': a, 'b': b, 'c': c, 'd': d, 'z': z}
     return z
 
-def test_dump_nested(test_file_name):
+def test_dump_nested(test_file_name,compression_kwargs):
     """ Dump a complicated nested object to HDF5
     """
     z = generate_nested()
-    dump(z, test_file_name, mode='w')
+    dump(z, test_file_name, mode='w',**compression_kwargs)
 
-def test_ndarray(test_file_name):
+def test_ndarray(test_file_name,compression_kwargs):
     a = np.array([1, 2, 3])
     b = np.array([2, 3, 4])
     z = (a, b)
 
     print("Original:")
     pprint(z)
-    dump(z, test_file_name, mode='w')
+    dump(z, test_file_name, mode='w',**compression_kwargs)
 
     print("\nReconstructed:")
     z = load(test_file_name)
     pprint(z)
 
 
-def test_ndarray_masked(test_file_name):
+def test_ndarray_masked(test_file_name,compression_kwargs):
     a = np.ma.array([1, 2, 3])
     b = np.ma.array([2, 3, 4], mask=[True, False, True])
     z = (a, b)
 
     print("Original:")
     pprint(z)
-    dump(z, test_file_name, mode='w')
+    dump(z, test_file_name, mode='w',**compression_kwargs)
 
     print("\nReconstructed:")
     z = load(test_file_name)
     pprint(z)
 
 
-def test_simple_dict(test_file_name):
+def test_simple_dict(test_file_name,compression_kwargs):
     a = {'key1': 1, 'key2': 2}
 
-    dump(a, test_file_name)
+    dump(a, test_file_name,**compression_kwargs)
     z = load(test_file_name)
 
     pprint(a)
     pprint(z)
 
 
-def test_complex_dict(test_file_name):
+def test_complex_dict(test_file_name,compression_kwargs):
     a = {'akey': 1, 'akey2': 2}
     c = {'ckey': "hello", "ckey2": "hi there"}
     z = {'zkey1': a, 'zkey2': a, 'zkey3': c}
 
     print("Original:")
     pprint(z)
-    dump(z, test_file_name, mode='w')
+    dump(z, test_file_name, mode='w',**compression_kwargs)
 
     print("\nReconstructed:")
     z = load(test_file_name)
     pprint(z)
 
-def test_complex(test_file_name):
+def test_complex(test_file_name,compression_kwargs):
     """ Test complex value dtype is handled correctly
 
     https://github.com/telegraphic/hickle/issues/29 """
 
     data = {"A": 1.5, "B": 1.5 + 1j, "C": np.linspace(0, 1, 4) + 2j}
-    dump(data, test_file_name)
+    dump(data, test_file_name,**compression_kwargs)
     data2 = load(test_file_name)
     for key in data.keys():
         assert isinstance(data[key], data2[key].__class__)
 
 
-def test_nonstring_keys(test_file_name):
+def test_nonstring_keys(test_file_name,compression_kwargs):
     """ Test that keys are reconstructed back to their original datatypes
     https://github.com/telegraphic/hickle/issues/36
     """
@@ -710,7 +726,7 @@ def test_nonstring_keys(test_file_name):
             }
 
     print(data)
-    dump(data, test_file_name)
+    dump(data, test_file_name,**compression_kwargs)
     data2 = load(test_file_name)
     print(data2)
 
@@ -719,7 +735,7 @@ def test_nonstring_keys(test_file_name):
 
     print(data2)
 
-
+@pytest.mark.no_compression
 def test_scalar_compression(test_file_name):
     """ Test bug where compression causes a crash on scalar datasets
 
@@ -736,12 +752,12 @@ def test_scalar_compression(test_file_name):
         assert isinstance(data[key], data2[key].__class__)
 
 
-def test_bytes(test_file_name):
+def test_bytes(test_file_name,compression_kwargs):
     """ Dumping and loading a string. PYTHON3 ONLY """
 
     mode = 'w'
     string_obj = b"The quick brown fox jumps over the lazy dog"
-    dump(string_obj, test_file_name, mode)
+    dump(string_obj, test_file_name, mode,**compression_kwargs)
     string_hkl = load(test_file_name)
     print(type(string_obj))
     print(type(string_hkl))
@@ -749,26 +765,26 @@ def test_bytes(test_file_name):
     assert string_obj == string_hkl
 
 
-def test_np_scalar(test_file_name):
+def test_np_scalar(test_file_name,compression_kwargs):
     """ Numpy scalar datatype
 
     https://github.com/telegraphic/hickle/issues/50
     """
 
     r0 = {'test': np.float64(10.)}
-    dump(r0, test_file_name)
+    dump(r0, test_file_name,**compression_kwargs)
     r = load(test_file_name)
     print(r)
     assert isinstance(r0['test'], r['test'].__class__)
 
 
-def test_slash_dict_keys(test_file_name):
+def test_slash_dict_keys(test_file_name,compression_kwargs):
     """ Support for having slashes in dict keys
 
     https://github.com/telegraphic/hickle/issues/124"""
     dct = {'a/b': [1, '2'], 1.4: 3}
 
-    dump(dct, test_file_name, 'w')
+    dump(dct, test_file_name, 'w',**compression_kwargs)
     dct_hkl = load(test_file_name)
 
     assert isinstance(dct_hkl, dict)
@@ -778,7 +794,7 @@ def test_slash_dict_keys(test_file_name):
     # Check that having backslashes in dict keys will serialize the dict
     dct2 = {'a\\b': [1, '2'], 1.4: 3}
     with pytest.warns(None) as not_expected:
-        dump(dct2, test_file_name)
+        dump(dct2, test_file_name,**compression_kwargs)
     assert not not_expected
 
 
diff --git a/hickle/tests/test_legacy_load.py b/hickle/tests/test_legacy_load.py
index e185ed4e..5a1c8391 100644
--- a/hickle/tests/test_legacy_load.py
+++ b/hickle/tests/test_legacy_load.py
@@ -40,6 +40,7 @@ def test_legacy_load():
                         print(item.attrs.items())
                     raise
 
+@pytest.mark.no_compression
 def test_4_0_0_load():
     """
     test that files created by hickle 4.0.x can be loaded by 
diff --git a/requirements_h5py.txt b/requirements_h5py.txt
new file mode 100644
index 00000000..5dbe831f
--- /dev/null
+++ b/requirements_h5py.txt
@@ -0,0 +1,4 @@
+dill>=0.3.0
+h5py>=2.8.0,<3
+numpy>=1.8
+six>=1.11.0
diff --git a/requirements_test.txt b/requirements_test.txt
index 36f1b43b..55c4c4d0 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -6,4 +6,3 @@ scipy>=1.0.0
 pandas>=0.24.0
 check-manifest
 twine>=1.13.0
-h5py<3
diff --git a/setup.cfg b/setup.cfg
index d1f49f6a..580980b5 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -13,3 +13,4 @@ omit=
   hickle/tests/*
   hickle/*/tests/*
   hickle/legacy_v3/*
+  hickle/loaders/load_pandas.py
diff --git a/tox.ini b/tox.ini
new file mode 100644
index 00000000..4dc11541
--- /dev/null
+++ b/tox.ini
@@ -0,0 +1,51 @@
+[tox]
+envlist = py{35,36,37,38}, py{35,36,37,38}-compress
+skip_missing_interpreters=true
+
+
+[testenv]
+passenv = HOME USER
+deps =
+	-rrequirements.txt
+	h5py3: -rrequirements_h5py_3.txt
+	-rrequirements_test.txt
+
+
+# {posargs} allows to pass any pytest related cli arguments
+# to tox after -- argument separator.
+commands =
+	pip install --upgrade pip
+	py{35,36,37,38}-!compress: pytest --cov-report=term-missing {posargs}
+	compress: pytest --enable-compression --cov-report=term-missing {posargs}
+
+[testenv:h5py3]
+# special environment for testing and debugging h5py >= 3.0 support
+# related issues. Manually calls python setup.py develop instead of 
+# python setup.py install which would also be possible below. 
+# system commands like mv, ln etc must be explicitly allowed to be
+# called from within the virtual environment
+skipdist=True
+allowlist_externals=
+	mv
+	ln
+	cp
+	rm
+
+# change h5py version requirements to >= 3.0 
+commands_pre=
+	mv requirements.txt requirements_mv.txt
+	ln -s requirements_h5py_3.txt requirements.txt
+commands =
+	python setup.py develop
+	pytest --cov-report=term-missing {posargs}
+
+# switch back to inital state again
+commands_post=
+	rm requirements.txt
+	cp requirements_mv.txt requirements.txt
+
+[pytest]
+# options to be passed to pytest in any cases as well
+# as any desired pytest configuration values
+addopts = --cov=./hickle 
+