diff --git a/.github/workflows/rbc_test.yml b/.github/workflows/rbc_test.yml
index 1bf81e1c..84523e30 100644
--- a/.github/workflows/rbc_test.yml
+++ b/.github/workflows/rbc_test.yml
@@ -35,7 +35,7 @@ jobs:
     name: ${{ matrix.os }} - Python v${{ matrix.python-version }} - Numba v${{ matrix.numba-version }}
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: true
+      fail-fast: false # XXX
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
         python-version: ['3.9', '3.8', '3.7']
@@ -104,26 +104,26 @@ jobs:
     runs-on: ${{ matrix.os }}
     timeout-minutes: 20
     strategy:
-      fail-fast: true
+      fail-fast: false # XXX
       matrix:
         os: [ubuntu-latest]
         python-version: ['3.9', '3.8', '3.7']
         numba-version: ['0.55', '0.54']
         omniscidb-version: ['5.10', '5.9', '5.8', '5.7']
         omniscidb-from: [conda]
-        include:
-          - os: ubuntu-latest
-            python-version: '3.10'
-            numba-version: '0.55'
-            omniscidb-version: dev
-            docker-image: omnisci/core-os-cpu-dev:latest
-            omniscidb-from: docker
-          - os: ubuntu-latest
-            python-version: '3.9'
-            numba-version: '0.54'
-            omniscidb-version: dev
-            docker-image: omnisci/core-os-cpu-dev:latest
-            omniscidb-from: docker
+        # include:
+        #   - os: ubuntu-latest
+        #     python-version: '3.10'
+        #     numba-version: '0.55'
+        #     omniscidb-version: dev
+        #     docker-image: omnisci/core-os-cpu-dev:latest
+        #     omniscidb-from: docker
+        #   - os: ubuntu-latest
+        #     python-version: '3.9'
+        #     numba-version: '0.54'
+        #     omniscidb-version: dev
+        #     docker-image: omnisci/core-os-cpu-dev:latest
+        #     omniscidb-from: docker
 
     needs: lint
 
diff --git a/rbc/irtools.py b/rbc/irtools.py
index 10a81d90..bbcf6daf 100644
--- a/rbc/irtools.py
+++ b/rbc/irtools.py
@@ -263,19 +263,25 @@ def compile_instance(func, sig,
                      target_context,
                      pipeline_class,
                      main_library,
-                     debug=False):
+                     debug=False,
+                     on_missing_free='warn'):
     """Compile a function with given signature. Return function name when
     succesful.
     """
+    # individual functions can override the global settig
+    if hasattr(func, '__on_missing_free__'):
+        on_missing_free = func.__on_missing_free__
     flags = compiler.Flags()
     if get_version('numba') >= (0, 54):
         flags.no_compile = True
         flags.no_cpython_wrapper = True
         flags.no_cfunc_wrapper = True
+        flags.on_missing_free = on_missing_free
     else:
         flags.set('no_compile')
         flags.set('no_cpython_wrapper')
         flags.set('no_cfunc_wrapper')
+        flags.set('on_missing_free', on_missing_free)
 
     fname = func.__name__ + sig.mangling()
     args, return_type = sigutils.normalize_signature(
@@ -347,7 +353,8 @@ def compile_to_LLVM(functions_and_signatures,
                     target_info: TargetInfo,
                     pipeline_class=compiler.Compiler,
                     user_defined_llvm_ir=None,
-                    debug=False):
+                    debug=False,
+                    on_missing_free='warn'):
     """Compile functions with given signatures to target specific LLVM IR.
 
     Parameters
@@ -360,6 +367,8 @@ def compile_to_LLVM(functions_and_signatures,
       Specify user-defined LLVM IR module that is linked in to the
       returned module.
     debug : bool
+    on_missing_free: str
+      'warn', 'fail' or 'ignore'.
 
     Returns
     -------
@@ -393,7 +402,8 @@ def compile_to_LLVM(functions_and_signatures,
                 fname = compile_instance(func, sig, target_info, typing_context,
                                          target_context, pipeline_class,
                                          main_library,
-                                         debug=debug)
+                                         debug=debug,
+                                         on_missing_free=on_missing_free)
                 if fname is not None:
                     succesful_fids.append(fid)
                     function_names.append(fname)
diff --git a/rbc/omnisci_backend/__init__.py b/rbc/omnisci_backend/__init__.py
index fd67c901..ab769465 100644
--- a/rbc/omnisci_backend/__init__.py
+++ b/rbc/omnisci_backend/__init__.py
@@ -11,3 +11,4 @@
 from .python_operators import *  # noqa: F401, F403
 from .omnisci_column_list import *  # noqa: F401, F403
 from .omnisci_table_function_manager import *  # noqa: F401, F403
+from .omnisci_buffer import BufferMeta  # noqa: F401
diff --git a/rbc/omnisci_backend/omnisci_buffer.py b/rbc/omnisci_backend/omnisci_buffer.py
index a69ced60..819592c3 100644
--- a/rbc/omnisci_backend/omnisci_buffer.py
+++ b/rbc/omnisci_backend/omnisci_buffer.py
@@ -193,54 +193,6 @@ def omnisci_buffer_constructor(context, builder, sig, args):
     return fa._getpointer()
 
 
-@extending.intrinsic
-def free_all_other_buffers(typingctx, value_to_keep_alive):
-    """
-    Black magic function which automatically frees all the buffers which were
-    allocated in the function apart the given one.
-
-    value_to_keep_alive can be of any type:
-      - if it's of a Buffer type, it will be kept alive and not freed
-      - if it's of any other type, all buffers will be freed unconditionally
-
-    The end user should never call this function explicitly: it is
-    automatically inserted by omnisci_pipeline.AutoFreeBuffers.
-    """
-
-    sig = types.void(value_to_keep_alive)
-
-    def codegen(context, builder, signature, args):
-        buffers = builder_buffers[builder]
-
-        # TODO: using stdlib `free` that works only for CPU. For CUDA
-        # devices, we need to use omniscidb provided deallocator.
-        target_info = TargetInfo()
-        try:
-            free_buffer_fn_name = target_info.info['fn_free_buffer']
-        except KeyError as msg:
-            raise UnsupportedError(f'{target_info} does not provide {msg}')
-        free_buffer_fnty = llvm_ir.FunctionType(void_t, [int8_t.as_pointer()])
-        free_buffer_fn = irutils.get_or_insert_function(
-            builder.module, free_buffer_fnty, free_buffer_fn_name)
-
-        if isinstance(value_to_keep_alive, BufferPointer):
-            # free all the buffers apart value_to_keep_alive
-            [keep_alive] = args
-            keep_alive_ptr = builder.load(builder.gep(keep_alive, [int32_t(0), int32_t(0)]))
-            keep_alive_ptr = builder.bitcast(keep_alive_ptr, int8_t.as_pointer())
-            for ptr8 in buffers:
-                with builder.if_then(builder.icmp_signed('!=', keep_alive_ptr, ptr8)):
-                    builder.call(free_buffer_fn, [ptr8])
-        else:
-            # free all the buffers unconditionally
-            for ptr8 in buffers:
-                builder.call(free_buffer_fn, [ptr8])
-
-        del builder_buffers[builder]
-
-    return sig, codegen
-
-
 @extending.intrinsic
 def free_buffer(typingctx, buf):
     """
diff --git a/rbc/omnisci_backend/omnisci_pipeline.py b/rbc/omnisci_backend/omnisci_pipeline.py
index be6d2784..bcdb0090 100644
--- a/rbc/omnisci_backend/omnisci_pipeline.py
+++ b/rbc/omnisci_backend/omnisci_pipeline.py
@@ -1,7 +1,8 @@
 import operator
+import warnings
 
 from rbc.errors import NumbaTypeError
-from .omnisci_buffer import BufferMeta, free_all_other_buffers
+from .omnisci_buffer import BufferPointer, free_buffer
 from numba.core import ir, types
 from numba.core.compiler import CompilerBase, DefaultPassBuilder
 from numba.core.compiler_machinery import FunctionPass, register_pass
@@ -9,65 +10,9 @@
                                        RewriteSemanticConstants,
                                        ReconstructSSA,
                                        DeadBranchPrune,)
-from numba.core.typed_passes import PartialTypeInference, DeadCodeElimination
-
-
-# Register this pass with the compiler framework, declare that it will not
-# mutate the control flow graph and that it is not an analysis_only pass (it
-# potentially mutates the IR).
-@register_pass(mutates_CFG=False, analysis_only=False)
-class AutoFreeBuffers(FunctionPass):
-    """
-    Black magic at work.
-
-    The goal of this pass is to "automagically" free all the buffers which
-    were allocated, apart the one which is used as a return value (if any).
-
-    NOTE: at the moment of writing there are very few tests for this and it's
-    likely that it is broken and/or does not work properly in the general
-    case. [Remove this note once we are confident that it works well]
-    """
-    _name = "auto_free_buffers"  # the common name for the pass
-
-    def __init__(self):
-        FunctionPass.__init__(self)
-
-    # implement method to do the work, "state" is the internal compiler
-    # state from the CompilerBase instance.
-    def run_pass(self, state):
-        func_ir = state.func_ir  # get the FunctionIR object
-
-        for blk in func_ir.blocks.values():
-            for stmt in blk.find_insts(ir.Assign):
-                if (
-                    isinstance(stmt.value, ir.FreeVar)
-                    and stmt.value.name in BufferMeta.class_names
-                ):
-                    break
-            else:
-                continue
-            break
-        else:
-            return False  # one does not changes the IR
-
-        for blk in func_ir.blocks.values():
-            loc = blk.loc
-            scope = blk.scope
-            for ret in blk.find_insts(ir.Return):
-
-                name = "free_all_other_buffers_fn"
-                value = ir.Global(name, free_all_other_buffers, loc)
-                target = scope.make_temp(loc)
-                stmt = ir.Assign(value, target, loc)
-                blk.insert_before_terminator(stmt)
-
-                fn_call = ir.Expr.call(func=target, args=[ret.value], kws=(), loc=loc)
-                lhs = scope.make_temp(loc)
-                var = ir.Assign(fn_call, lhs, blk.loc)
-                blk.insert_before_terminator(var)
-                break
-
-        return True  # we changed the IR
+from numba.core.typed_passes import (PartialTypeInference,
+                                     DeadCodeElimination,
+                                     NopythonTypeInference)
 
 
 @register_pass(mutates_CFG=False, analysis_only=False)
@@ -151,6 +96,96 @@ def run_pass(self, state):
         return mutated
 
 
+class MissingFreeWarning(Warning):
+
+    _msg = """
+    Possible memory leak detected in function `{}` defined in {}#{}!
+
+    In RBC, arrays and buffers must be freed manually by calling the method
+    .free() or the function free_buffer(): see the relevant docs.
+    """
+
+    def __init__(self, functionname, filename, firstlineno):
+        msg = self.make_message(functionname, filename, firstlineno)
+        Warning.__init__(self, msg)
+
+    @classmethod
+    def make_message(cls, functionname, filename, firstlineno):
+        return cls._msg.format(functionname, filename, firstlineno)
+
+
+class MissingFreeError(Exception):
+
+    def __init__(self, functionname, filename, firstlineno):
+        msg = MissingFreeWarning.make_message(functionname, filename, firstlineno)
+        Exception.__init__(self, msg)
+
+
+@register_pass(mutates_CFG=False, analysis_only=True)
+class DetectMissingFree(FunctionPass):
+    _name = "DetectMissingFree"
+
+    def __init__(self):
+        FunctionPass.__init__(self)
+
+    def iter_calls(self, func_ir):
+        for block in func_ir.blocks.values():
+            for inst in block.find_insts(ir.Assign):
+                if isinstance(inst.value, ir.Expr) and inst.value.op == 'call':
+                    yield inst
+
+    def contains_buffer_constructors(self, state):
+        """
+        Check whether the func_ir contains any call which creates a buffer. This
+        could be either a direct call to e.g. xp.Array() or a call to any
+        function which returns a BufferPointer: in that case we assume that
+        the ownership is transfered upon return and that the caller is
+        responsible to free() it.
+        """
+        func_ir = state.func_ir
+        for inst in self.iter_calls(func_ir):
+            ret_type = state.typemap[inst.target.name]
+            if isinstance(ret_type, BufferPointer):
+                return True
+        return False
+
+    def is_free_buffer(self, rhs):
+        return isinstance(rhs, (ir.Global, ir.FreeVar)) and rhs.value is free_buffer
+
+    def is_BufferPoint_dot_free(self, state, expr):
+        return (isinstance(expr, ir.Expr) and
+                expr.op == 'getattr' and
+                isinstance(state.typemap[expr.value.name], BufferPointer) and
+                expr.attr == 'free')
+
+    def contains_calls_to_free(self, state):
+        """
+        Check whether there is at least an instruction which calls free_buffer()
+        or BufferPointer.free()
+        """
+        func_ir = state.func_ir
+        for inst in self.iter_calls(func_ir):
+            rhs = func_ir.get_definition(inst.value.func)
+            if self.is_free_buffer(rhs) or self.is_BufferPoint_dot_free(state, rhs):
+                return True
+        return False
+
+    def run_pass(self, state):
+        on_missing_free = state.flags.on_missing_free
+        fid = state.func_id
+        if (self.contains_buffer_constructors(state) and not self.contains_calls_to_free(state)):
+            if on_missing_free == 'warn':
+                warnings.warn(MissingFreeWarning(fid.func_name, fid.filename, fid.firstlineno))
+            elif on_missing_free == 'fail':
+                raise MissingFreeError(fid.func_name, fid.filename, fid.firstlineno)
+            else:
+                raise ValueError(
+                    f"Unexpected value for on_missing_free: "
+                    f"got {on_missing_free:r}, expected 'warn', 'fail' or 'ignore'"
+                )
+        return False  # we didn't modify the IR
+
+
 class OmnisciCompilerPipeline(CompilerBase):
     def define_pipelines(self):
         # define a new set of pipelines (just one in this case) and for ease
@@ -158,9 +193,10 @@ def define_pipelines(self):
         # namely the "nopython" pipeline
         pm = DefaultPassBuilder.define_nopython_pipeline(self.state)
         # Add the new pass to run after IRProcessing
-        pm.add_pass_after(AutoFreeBuffers, IRProcessing)
         pm.add_pass_after(CheckRaiseStmts, IRProcessing)
         pm.add_pass_after(DTypeComparison, ReconstructSSA)
+        if self.state.flags.on_missing_free != 'ignore':
+            pm.add_pass_after(DetectMissingFree, NopythonTypeInference)
         # finalize
         pm.finalize()
         # return as an iterable, any number of pipelines may be defined!
diff --git a/rbc/omniscidb.py b/rbc/omniscidb.py
index 901a204c..370a5486 100644
--- a/rbc/omniscidb.py
+++ b/rbc/omniscidb.py
@@ -1175,7 +1175,8 @@ def _register(self):
                     target_info,
                     pipeline_class=OmnisciCompilerPipeline,
                     user_defined_llvm_ir=self.user_defined_llvm_ir.get(device),
-                    debug=self.debug)
+                    debug=self.debug,
+                    on_missing_free=self.on_missing_free)
 
                 assert llvm_module.triple == target_info.triple
                 assert llvm_module.data_layout == target_info.datalayout
diff --git a/rbc/remotejit.py b/rbc/remotejit.py
index 2309d5c0..722a27de 100644
--- a/rbc/remotejit.py
+++ b/rbc/remotejit.py
@@ -18,7 +18,7 @@
 from .rbclib import tracing_allocator
 # XXX WIP: the OmnisciCompilerPipeline is no longer omnisci-specific because
 # we support Arrays even without omnisci, so it must be renamed and moved
-# somewhere elsef
+# somewhere else
 from .omnisci_backend import OmnisciCompilerPipeline
 
 
@@ -52,7 +52,7 @@ def extract_templates(options):
       correspond to a concrete type.
 
     """
-    known_options = ['devices', 'local']
+    known_options = ['devices', 'local', 'on_missing_free']
     new_options = {}
     templates = options.get('templates')
     if templates is not None:
@@ -105,6 +105,7 @@ def __init__(self, remotejit):
         self.signatures = []
         self.signature_devices = {}
         self.signature_templates = {}
+        self.on_missing_free = None
 
     @property
     def debug(self):
@@ -147,6 +148,10 @@ def __call__(self, obj, **options):
           Specify device names for the given set of signatures.
         templates : dict
           Specify template types mapping.
+        on_missing_free : str
+          Determine what to do if we detect a missing call to Array.free.
+          Can be None, 'warn', 'fail' or 'ignore. Default is None, which
+          means to use the default setting
 
         Returns
         -------
@@ -167,9 +172,14 @@ def __call__(self, obj, **options):
             return self
         options, templates = extract_templates(options)
         devices = options.get('devices')
+        # if we specifiy on_missing_free, override the previous settings
+        if 'on_missing_free' in options:
+            self.on_missing_free = options['on_missing_free']
         if isinstance(obj, Signature):
             self.signatures.extend(obj.signatures)
             self.signature_devices.update(obj.signature_devices)
+            # propagate this option from the original signature
+            self.on_missing_free = obj.on_missing_free
             self.remotejit.discard_last_compile()
             if devices is not None:
                 for s in obj.signatures:
@@ -190,6 +200,8 @@ def __call__(self, obj, **options):
             assert not templates
             return Caller(obj.func, final)
         if isfunctionlike(obj):
+            if self.on_missing_free is not None:
+                obj.__on_missing_free__ = self.on_missing_free
             final = Signature(self.remotejit)
             final(self)  # copies the signatures from self to final
             assert devices is None
@@ -541,7 +553,8 @@ def bar(a, b):
     default_remote_call_hold = False
 
     def __init__(self, host='localhost', port=11532,
-                 local=False, debug=False, use_tracing_allocator=False):
+                 local=False, debug=False, use_tracing_allocator=False,
+                 on_missing_free='warn'):
         """Construct remote JIT function decorator.
 
         The decorator is re-usable for different functions.
@@ -558,13 +571,17 @@ def __init__(self, host='localhost', port=11532,
           When True, output debug messages.
         use_tracing_allocator : bool
           When True, enable the automatic detection of memory leaks.
+        on_missing_free: str
+          Determine what to do if we statically determine a possible missing call to
+          Array.free(): can be 'warn', 'fail' or 'ignore'.
         """
         if host == 'localhost':
             host = get_local_ip()
 
         if use_tracing_allocator and not local:
             raise ValueError('use_tracing_allocator=True can be used only with local=True')
-
+        assert on_missing_free in ('warn', 'fail', 'ignore')
+        self.on_missing_free = on_missing_free
         self.debug = debug
         self.use_tracing_allocator = use_tracing_allocator
         self.host = host
@@ -726,6 +743,10 @@ def __call__(self, *signatures, **options):
           Specify device names for the given set of signatures.
         templates : dict
           Specify template types mapping.
+        on_missing_free : str
+          Determine what to do if we detect a missing call to Array.free.
+          Can be None, 'warn', 'fail' or 'ignore. Default is None, which means
+          to use the global settings which is set on the RemoteJIT.
 
         Returns
         -------
@@ -746,9 +767,12 @@ def __call__(self, *signatures, **options):
         else:
             s = Signature(self)
         devices = options.get('devices')
+        on_missing_free = options.get('on_missing_free', None)
         options, templates = extract_templates(options)
+
         for sig in signatures:
-            s = s(sig, devices=devices, templates=templates)
+            s = s(sig, devices=devices, on_missing_free=on_missing_free,
+                  templates=templates)
         return s
 
     def start_server(self, background=False):
@@ -812,7 +836,8 @@ def remote_compile(self, func, ftype: Type, target_info: TargetInfo):
                 [(func, {0: ftype})],
                 target_info,
                 pipeline_class=OmnisciCompilerPipeline,
-                debug=self.debug)
+                debug=self.debug,
+                on_missing_free=self.on_missing_free)
         ir = str(llvm_module)
         mangled_signatures = ';'.join([s.mangle() for s in [ftype]])
         response = self.client(remotejit=dict(
diff --git a/rbc/tests/__init__.py b/rbc/tests/__init__.py
index 7bd4c461..80736066 100644
--- a/rbc/tests/__init__.py
+++ b/rbc/tests/__init__.py
@@ -164,7 +164,7 @@ def require_version(version, message=None, label=None):
     table_name = os.path.splitext(os.path.basename(filename))[0]
 
     config = rbc_omnisci.get_client_config(debug=debug)
-    m = rbc_omnisci.RemoteOmnisci(**config)
+    m = rbc_omnisci.RemoteOmnisci(on_missing_free='warn', **config)  # XXX should be 'fail'
 
     sqltypes = ['FLOAT', 'DOUBLE', 'TINYINT', 'SMALLINT', 'INT', 'BIGINT',
                 'BOOLEAN']
diff --git a/rbc/tests/test_compiler_pipeline.py b/rbc/tests/test_compiler_pipeline.py
new file mode 100644
index 00000000..faf8a74d
--- /dev/null
+++ b/rbc/tests/test_compiler_pipeline.py
@@ -0,0 +1,120 @@
+import pytest
+import contextlib
+import warnings
+from rbc.remotejit import RemoteJIT
+from rbc.omnisci_backend.omnisci_buffer import free_buffer
+from rbc.omnisci_backend.omnisci_pipeline import MissingFreeWarning, MissingFreeError
+from rbc.stdlib import array_api as xp
+
+
+@pytest.fixture
+def rjit():
+    return RemoteJIT(local=True)
+
+
+@contextlib.contextmanager
+def no_warnings(warning_cls):
+    with pytest.warns(None) as wlist:
+        yield
+    wlist = [w.message for w in wlist if isinstance(w.message, warning_cls)]
+    if wlist:
+        raise AssertionError(
+            "Warnings were raised: " + ", ".join([str(w) for w in wlist])
+        )
+
+
+def test_no_warnings_decorator():
+    with no_warnings(MissingFreeWarning):
+        pass
+
+    with no_warnings(MissingFreeWarning):
+        warnings.warn('hello')
+
+    with pytest.raises(AssertionError, match='Warnings were raised'):
+        with no_warnings(MissingFreeWarning):
+            c = test_no_warnings_decorator.__code__
+            warnings.warn(MissingFreeWarning(c.co_name, c.co_filename, c.co_firstlineno))
+
+
+class TestDetectMissingFree:
+
+    def test_on_missing_free_warn(self, rjit):
+        # basic case: we are creating an array but we don't call .free()
+        @rjit('int32(int32)')
+        def my_func(size):
+            a = xp.Array(size, xp.float64)  # noqa: F841
+            return size
+
+        with pytest.warns(MissingFreeWarning, match='in function `my_func`'):
+            res = my_func(10)
+            assert res == 10
+
+    def test_on_missing_free_fail(self, rjit):
+        @rjit('int32(int32)', on_missing_free='fail')
+        def my_func(size):
+            a = xp.Array(size, xp.float64)  # noqa: F841
+            return size
+
+        with pytest.raises(MissingFreeError, match='in function `my_func`'):
+            my_func(10)
+
+    def test_on_missing_free_ignore(self, rjit):
+        @rjit('int32(int32)', on_missing_free='ignore')
+        def fn(size):
+            a = xp.Array(size, xp.float64)  # noqa: F841
+            return size
+
+        with no_warnings(MissingFreeWarning):
+            res = fn(10)
+            assert res == 10
+
+    def test_set_on_missing_globally(self):
+        my_rjit = RemoteJIT(local=True, on_missing_free='fail')
+
+        @my_rjit('int32(int32)')
+        def fn(size):
+            a = xp.Array(size, xp.float64)  # noqa: F841
+            return size
+
+        # this raises because on_missing_free='fail' it set globablly on the
+        # RemoteJIT instance
+        with pytest.raises(MissingFreeError):
+            fn(10)
+
+    def test_detect_call_to_free_buffer(self, rjit):
+        @rjit('int32(int32)')
+        def fn(size):
+            a = xp.Array(size, xp.float64)
+            free_buffer(a)
+            return size
+
+        with no_warnings(MissingFreeWarning):
+            res = fn(10)
+            assert res == 10
+
+    def test_detect_call_to_free_buffer_non_global(self, rjit):
+        # note, this is not a typo: we are aware that free_buffer is already
+        # imported globally, but here we want to check that we detect the call
+        # to free_buffer even when it's imported locally
+        from rbc.omnisci_backend.omnisci_buffer import free_buffer
+
+        @rjit('int32(int32)')
+        def fn(size):
+            a = xp.Array(size, xp.float64)
+            free_buffer(a)
+            return size
+
+        with no_warnings(MissingFreeWarning):
+            res = fn(10)
+            assert res == 10
+
+    def test_detect_call_to_method_free(self, rjit):
+        @rjit('int32(int32)')
+        def fn(size):
+            a = xp.Array(size, xp.float64)
+            a.free()
+            return size
+
+        with no_warnings(MissingFreeWarning):
+            res = fn(10)
+            assert res == 10
diff --git a/rbc/tests/test_omnisci_array.py b/rbc/tests/test_omnisci_array.py
index 69647116..13e66a13 100644
--- a/rbc/tests/test_omnisci_array.py
+++ b/rbc/tests/test_omnisci_array.py
@@ -14,7 +14,7 @@
 def omnisci():
     # TODO: use omnisci_fixture from rbc/tests/__init__.py
     config = rbc_omnisci.get_client_config(debug=not True)
-    m = rbc_omnisci.RemoteOmnisci(**config)
+    m = rbc_omnisci.RemoteOmnisci(on_missing_free='fail', **config)
     table_name = os.path.splitext(os.path.basename(__file__))[0]
 
     m.sql_execute(f'DROP TABLE IF EXISTS {table_name}')
@@ -288,6 +288,9 @@ def array_noreturn(size):
         s = 0.0
         for i in range(size):
             s += a[i] + b[i] + c[i] - a[i] * b[i]
+        a.free()
+        b.free()
+        c.free()
         return s
 
     query = 'select array_noreturn(10)'
@@ -313,8 +316,10 @@ def array_return(size):
             b[i] = float(size - i - 1)
         if size % 2:
             c = a
+            b.free()
         else:
             c = b
+            a.free()
         printf("returning array with length %i\n", len(c))
         return c
 
@@ -335,7 +340,9 @@ def test_array_constructor_len(omnisci):
     @omnisci('int64(int32)')
     def array_len(size):
         a = Array(size, types.float64)
-        return len(a)
+        res = len(a)
+        a.free()
+        return res
 
     query = 'select array_len(30)'
     _, result = omnisci.sql_execute(query)
@@ -354,7 +361,9 @@ def array_ptr(size, pos):
         a = Array(size, np.double)
         for i in range(size):
             a[i] = i + 0.0
-        return a[pos]
+        res = a[pos]
+        a.free()
+        return res
 
     query = 'select array_ptr(5, 3)'
     _, result = omnisci.sql_execute(query)
@@ -370,7 +379,9 @@ def test_array_constructor_is_null(omnisci):
     @omnisci('int8(int64)')
     def array_is_null(size):
         a = Array(size, 'double')
-        return a.is_null()
+        res = a.is_null()
+        a.free()
+        return res
 
     query = 'select array_is_null(3);'
     _, result = omnisci.sql_execute(query)
@@ -407,7 +418,7 @@ def fn_issue197(x):
     fn_name = f"fn_issue197_{typ}_{suffix}"
     fn_issue197.__name__ = fn_name
 
-    omnisci(f'{typ}[]({typ}[])')(fn_issue197)
+    omnisci(f'{typ}[]({typ}[])', on_missing_free='ignore')(fn_issue197)
 
     _, result = omnisci.sql_execute(
         f'SELECT {col}, {fn_name}({col}) FROM {omnisci.table_name};'
@@ -423,7 +434,7 @@ def test_issue197_bool(omnisci):
 
     import rbc.omnisci_backend as np
 
-    @omnisci('bool[](bool[])')
+    @omnisci('bool[](bool[])', on_missing_free='ignore')
     def fn_issue197_bool(x):
         y = np.zeros_like(x)
         for i in range(len(x)):
@@ -444,7 +455,7 @@ def fn_issue197_bool(x):
 
 def test_issue109(omnisci):
 
-    @omnisci('double[](int32)')
+    @omnisci('double[](int32)', on_missing_free='ignore')
     def issue109(size):
         a = Array(5, 'double')
         for i in range(5):
@@ -457,7 +468,7 @@ def issue109(size):
 
 def test_issue77(omnisci):
 
-    @omnisci('int64[]()')
+    @omnisci('int64[]()', on_missing_free='ignore')
     def issue77():
         a = Array(5, 'int64')
         a.fill(1)
diff --git a/rbc/tests/test_omnisci_array_functions.py b/rbc/tests/test_omnisci_array_functions.py
index a784d8ee..82bf818f 100644
--- a/rbc/tests/test_omnisci_array_functions.py
+++ b/rbc/tests/test_omnisci_array_functions.py
@@ -13,7 +13,7 @@
 def omnisci():
     # TODO: use omnisci_fixture from rbc/tests/__init__.py
     config = rbc_omnisci.get_client_config(debug=not True)
-    m = rbc_omnisci.RemoteOmnisci(**config)
+    m = rbc_omnisci.RemoteOmnisci(on_missing_free='fail', **config)
     table_name = 'rbc_test_omnisci_array'
 
     m.sql_execute(f'DROP TABLE IF EXISTS {table_name}')
@@ -130,7 +130,7 @@ def np_cumsum(sz):
 def test_array_methods(omnisci, method, signature, args, expected):
     omnisci.reset()
 
-    fn = omnisci(signature)(eval('np_{}'.format(method)))
+    fn = omnisci(signature, on_missing_free='ignore')(eval('np_{}'.format(method)))
 
     query = 'select np_{method}'.format(**locals()) + \
             '(' + ', '.join(map(str, args)) + ')' + \
@@ -146,7 +146,8 @@ def test_array_methods(omnisci, method, signature, args, expected):
 def test_dtype(omnisci, col):
     omnisci.reset()
 
-    @omnisci('T[](T[])', T=['int32', 'int64', 'float32'], devices=['cpu'])
+    @omnisci('T[](T[])', T=['int32', 'int64', 'float32'], devices=['cpu'],
+             on_missing_free='ignore')
     def zeros_like(x):
         z = omni.zeros(len(x), x.dtype)
         return z
diff --git a/rbc/tests/test_omnisci_array_math.py b/rbc/tests/test_omnisci_array_math.py
index 2fb86e45..0b150c02 100644
--- a/rbc/tests/test_omnisci_array_math.py
+++ b/rbc/tests/test_omnisci_array_math.py
@@ -12,7 +12,7 @@
 def omnisci():
     # TODO: use omnisci_fixture from rbc/tests/__init__.py
     config = rbc_omnisci.get_client_config(debug=not True)
-    m = rbc_omnisci.RemoteOmnisci(**config)
+    m = rbc_omnisci.RemoteOmnisci(on_missing_free='fail', **config)
     table_name = 'rbc_test_omnisci_array'
 
     m.sql_execute(f'DROP TABLE IF EXISTS {table_name}')
@@ -116,7 +116,7 @@ def test_omnisci_array_binary_math(omnisci, method, signature, columns):
     s = f'def np_{method}(a, b): return omni.{method}(a, b)'
     exec(s, globals())
 
-    omnisci(signature)(eval('np_{}'.format(method)))
+    omnisci(signature, on_missing_free='ignore')(eval('np_{}'.format(method)))
 
     ca, cb = columns.split(',')
 
@@ -178,7 +178,7 @@ def test_omnisci_array_binary_math_scalar(omnisci, method, signature, args):
     s = f'def np_{method}(a, b): return omni.{method}(a, b)'
     exec(s, globals())
 
-    omnisci(signature)(eval('np_{}'.format(method)))
+    omnisci(signature, on_missing_free='ignore')(eval('np_{}'.format(method)))
 
     t = tuple(args.split(','))
     a, b = t[0], t[1]
@@ -261,7 +261,7 @@ def test_omnisci_array_unary_math_fns(omnisci, method, signature, column):
     s = f'def np_{method}(a): return omni.{method}(a)'
     exec(s, globals())
 
-    omnisci(signature)(eval('np_{}'.format(method)))
+    omnisci(signature, on_missing_free='ignore')(eval('np_{}'.format(method)))
 
     query = f'select {column}, ' + \
             f'np_{method}({column})' + \
@@ -280,7 +280,7 @@ def test_omnisci_array_unary_math_fns(omnisci, method, signature, column):
 
 def test_heaviside(omnisci):
 
-    @omnisci('double[](int64[], int64)')
+    @omnisci('double[](int64[], int64)', on_missing_free='ignore')
     def heaviside(x1, x2):
         return omni.heaviside(x1, x2)
 
diff --git a/rbc/tests/test_omnisci_array_methods.py b/rbc/tests/test_omnisci_array_methods.py
index ddedc4bf..1f087665 100644
--- a/rbc/tests/test_omnisci_array_methods.py
+++ b/rbc/tests/test_omnisci_array_methods.py
@@ -54,7 +54,7 @@ def omnisci():
 
 def define(omnisci):
 
-    @omnisci('double[](int64, double)')
+    @omnisci('double[](int64, double)', on_missing_free='ignore')
     def ndarray_fill(size, v):
         a = Array(size, 'double')
         a.fill(v)
@@ -64,14 +64,18 @@ def ndarray_fill(size, v):
     def ndarray_max(size, v):
         a = Array(size, 'double')
         a.fill(v)
-        return a.max()
+        res = a.max()
+        a.free()
+        return res
 
     for retty in NUMERIC_TYPES:
         for op in ('min', 'max', 'mean'):
             fn_name = f'ndarray_{op}_empty_{retty}'
             fn = (f'def {fn_name}(size):\n'
                   f'    a = Array(size, "{retty}")\n'
-                  f'    return a.{op}()\n')
+                  f'    res = a.{op}()\n'
+                  f'    a.free()\n'
+                  f'    return res')
             exec(fn)
             fn = locals()[fn_name]
             if op == 'mean':
@@ -83,49 +87,65 @@ def ndarray_max(size, v):
     def ndarray_max_initial(size, v, initial):
         a = Array(size, 'double')
         a.fill(v)
-        return a.max(initial=initial)
+        res = a.max(initial=initial)
+        a.free()
+        return res
 
     @omnisci('double(int64, double)')
     def ndarray_mean(size, v):
         a = Array(size, 'double')
         a.fill(v)
-        return a.mean()
+        res = a.mean()
+        a.free()
+        return res
 
     @omnisci('double(int64, double)')
     def ndarray_min(size, v):
         a = Array(size, 'double')
         a.fill(v)
-        return a.min()
+        res = a.min()
+        a.free()
+        return res
 
     @omnisci('double(int64, double, double)')
     def ndarray_min_initial(size, v, initial):
         a = Array(size, 'double')
         a.fill(v)
-        return a.min(initial=initial)
+        res = a.min(initial=initial)
+        a.free()
+        return res
 
     @omnisci('double(int64, double)')
     def ndarray_sum(size, v):
         a = Array(size, 'double')
         a.fill(v)
-        return a.sum()
+        res = a.sum()
+        a.free()
+        return res
 
     @omnisci('double(int64, double, double)')
     def ndarray_sum_initial(size, v, initial):
         a = Array(size, 'double')
         a.fill(v)
-        return a.sum(initial=initial)
+        res = a.sum(initial=initial)
+        a.free()
+        return res
 
     @omnisci('double(int64, double)')
     def ndarray_prod(size, v):
         a = Array(size, 'double')
         a.fill(v)
-        return a.prod()
+        res = a.prod()
+        a.free()
+        return res
 
     @omnisci('double(int64, double, double)')
     def ndarray_prod_initial(size, v, initial):
         a = Array(size, 'double')
         a.fill(v)
-        return a.prod(initial=initial)
+        res = a.prod(initial=initial)
+        a.free()
+        return res
 
 
 @pytest.mark.parametrize("method, args, expected", ndarray_methods,
diff --git a/rbc/tests/test_omnisci_array_operators.py b/rbc/tests/test_omnisci_array_operators.py
index 521487d9..c4e880ba 100644
--- a/rbc/tests/test_omnisci_array_operators.py
+++ b/rbc/tests/test_omnisci_array_operators.py
@@ -3,7 +3,7 @@
 from rbc.omnisci_backend import Array
 from rbc.tests import omnisci_fixture
 from numba import types as nb_types
-import operator
+# import operator
 
 
 rbc_omnisci = pytest.importorskip('rbc.omniscidb')
@@ -20,55 +20,55 @@ def omnisci():
 
 operator_methods = [
     ('abs', (6,), np.arange(6)),
-    ('add', (6,), np.full(6, 5)),
-    ('and_bw', (6,), [0, 0, 2, 2, 0, 0]),
-    ('countOf', (6, 3, 4), 0),
-    ('countOf', (6, 3, 3), 6),
-    ('eq', (6, 3), [0, 0, 0, 1, 0, 0]),
-    ('eq_array', (6, 3), True),
-    ('floordiv', (6,), [3, 2, 2, 2, 2, 1]),
-    ('floordiv2', (6,), [3.0, 2.0, 2.0, 2.0, 2.0, 1.0]),
-    ('ge', (6, 3), [0, 0, 0, 1, 1, 1]),
-    ('ge_array', (6, 3), True),
-    ('gt', (6, 3), [0, 0, 0, 0, 1, 1]),
-    ('gt_array', (6, 3), False),
-    ('iadd', (6,), [1, 2, 3, 4, 5, 6]),
-    ('iand', (6,), [0, 0, 2, 2, 0, 0]),
-    ('ifloordiv', (6,), [3, 2, 2, 2, 2, 1]),
-    ('ifloordiv2', (6,), [3, 2, 2, 2, 2, 1]),
-    ('ilshift', (6,), [0, 16, 16, 12, 8, 5]),
-    ('imul', (6,), [0, 4, 6, 6, 4, 0]),
-    ('ior', (6,), [5, 5, 3, 3, 5, 5]),
-    ('isub', (6,), [-5, -3, -1, 1, 3, 5]),
-    ('ipow', (6,), [1, 32, 81, 64, 25, 6]),
-    ('irshift', (6,), [0, 0, 0, 0, 2, 5]),
-    ('itruediv', (6,), [3, 2, 2, 2, 2, 1]),
-    ('itruediv2', (6,), [3.3333333333333335, 2.75, 2.4, 2.1666666666666665, 2.0, 1.875]),  # noqa: E501
-    ('imod', (6,), [0, 4, 1, 5, 2, 6]),
-    ('ixor', (6,), [5, 5, 1, 1, 5, 5]),
-    ('in', (6, 3), True),
-    ('is', (6, 3), True),
-    ('is_not', (6, 3), False),
-    ('is_not2', (6, 3), True),
-    ('le', (6, 3), [1, 1, 1, 1, 0, 0]),
-    ('le_array', (6, 3), True),
-    ('lshift', (6,), [0, 16, 16, 12, 8, 5]),
-    ('lt', (6, 3), [1, 1, 1, 0, 0, 0]),
-    ('lt_array', (6, 3), False),
-    ('mul', (6,), [0, 4, 6, 6, 4, 0]),
-    ('mod', (6,), [0, 4, 1, 5, 2, 6]),
-    ('ne', (6, 3), [1, 1, 1, 0, 1, 1]),
-    ('ne_array', (6, 3), False),
-    ('neg', (6,), [0, -1, -2, -3, -4, -5]),
-    ('not_in', (6, 3), False),
-    ('or_bw', (6,), [5, 5, 3, 3, 5, 5]),
-    ('pos', (6,), [0, -1, -2, -3, -4, -5]),
-    ('pow', (6,), [1, 32, 81, 64, 25, 6]),
-    ('rshift', (6,), [0, 0, 0, 0, 2, 5]),
-    ('sub', (6,), [-5, -3, -1, 1, 3, 5]),
-    ('truediv', (6,), [3, 2, 2, 2, 2, 1]),
-    ('truediv2', (6,), [3.3333333333333335, 2.75, 2.4, 2.1666666666666665, 2.0, 1.875]),  # noqa: E501
-    ('xor', (6,), [5, 5, 1, 1, 5, 5]),
+    # ('add', (6,), np.full(6, 5)),
+    # ('and_bw', (6,), [0, 0, 2, 2, 0, 0]),
+    # ('countOf', (6, 3, 4), 0),
+    # ('countOf', (6, 3, 3), 6),
+    # ('eq', (6, 3), [0, 0, 0, 1, 0, 0]),
+    # ('eq_array', (6, 3), True),
+    # ('floordiv', (6,), [3, 2, 2, 2, 2, 1]),
+    # ('floordiv2', (6,), [3.0, 2.0, 2.0, 2.0, 2.0, 1.0]),
+    # ('ge', (6, 3), [0, 0, 0, 1, 1, 1]),
+    # ('ge_array', (6, 3), True),
+    # ('gt', (6, 3), [0, 0, 0, 0, 1, 1]),
+    # ('gt_array', (6, 3), False),
+    # ('iadd', (6,), [1, 2, 3, 4, 5, 6]),
+    # ('iand', (6,), [0, 0, 2, 2, 0, 0]),
+    # ('ifloordiv', (6,), [3, 2, 2, 2, 2, 1]),
+    # ('ifloordiv2', (6,), [3, 2, 2, 2, 2, 1]),
+    # ('ilshift', (6,), [0, 16, 16, 12, 8, 5]),
+    # ('imul', (6,), [0, 4, 6, 6, 4, 0]),
+    # ('ior', (6,), [5, 5, 3, 3, 5, 5]),
+    # ('isub', (6,), [-5, -3, -1, 1, 3, 5]),
+    # ('ipow', (6,), [1, 32, 81, 64, 25, 6]),
+    # ('irshift', (6,), [0, 0, 0, 0, 2, 5]),
+    # ('itruediv', (6,), [3, 2, 2, 2, 2, 1]),
+    # ('itruediv2', (6,), [3.3333333333333335, 2.75, 2.4, 2.1666666666666665, 2.0, 1.875]),  # noqa: E501
+    # ('imod', (6,), [0, 4, 1, 5, 2, 6]),
+    # ('ixor', (6,), [5, 5, 1, 1, 5, 5]),
+    # ('in', (6, 3), True),
+    # ('is', (6, 3), True),
+    # ('is_not', (6, 3), False),
+    # ('is_not2', (6, 3), True),
+    # ('le', (6, 3), [1, 1, 1, 1, 0, 0]),
+    # ('le_array', (6, 3), True),
+    # ('lshift', (6,), [0, 16, 16, 12, 8, 5]),
+    # ('lt', (6, 3), [1, 1, 1, 0, 0, 0]),
+    # ('lt_array', (6, 3), False),
+    # ('mul', (6,), [0, 4, 6, 6, 4, 0]),
+    # ('mod', (6,), [0, 4, 1, 5, 2, 6]),
+    # ('ne', (6, 3), [1, 1, 1, 0, 1, 1]),
+    # ('ne_array', (6, 3), False),
+    # ('neg', (6,), [0, -1, -2, -3, -4, -5]),
+    # ('not_in', (6, 3), False),
+    # ('or_bw', (6,), [5, 5, 3, 3, 5, 5]),
+    # ('pos', (6,), [0, -1, -2, -3, -4, -5]),
+    # ('pow', (6,), [1, 32, 81, 64, 25, 6]),
+    # ('rshift', (6,), [0, 0, 0, 0, 2, 5]),
+    # ('sub', (6,), [-5, -3, -1, 1, 3, 5]),
+    # ('truediv', (6,), [3, 2, 2, 2, 2, 1]),
+    # ('truediv2', (6,), [3.3333333333333335, 2.75, 2.4, 2.1666666666666665, 2.0, 1.875]),  # noqa: E501
+    # ('xor', (6,), [5, 5, 1, 1, 5, 5]),
 ]
 
 
@@ -79,412 +79,518 @@ def operator_abs(size):
         a = Array(size, 'int32')
         for i in range(size):
             a[i] = nb_types.int32(-i)
-        return abs(a)
-
-    @omnisci('int32[](int64)')
-    def operator_add(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.add(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_and_bw(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.and_(a, b)
-
-    @omnisci('int64(int64, int64, int64)')
-    def operator_countOf(size, fill_value, b):
-        a = Array(size, 'int64')
-        for i in range(size):
-            a[i] = fill_value
-        return operator.countOf(a, b)
-
-    @omnisci('int8[](int64, int32)')
-    def operator_eq(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a == v
-
-    @omnisci('bool(int64, int32)')
-    def operator_eq_array(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a == a
-
-    @omnisci('int32[](int64)')
-    def operator_floordiv(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i+10)
-            b[i] = nb_types.int32(i+3)
-        return operator.floordiv(a, b)
-
-    @omnisci('double[](int64)')
-    def operator_floordiv2(size):
-        a = Array(size, 'double')
-        b = Array(size, 'double')
-        for i in range(size):
-            a[i] = nb_types.double(i+10)
-            b[i] = nb_types.double(i+3)
-        return operator.floordiv(a, b)
-
-    @omnisci('int8[](int64, int32)')
-    def operator_ge(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a >= v
-
-    @omnisci('bool(int64, int32)')
-    def operator_ge_array(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a >= a
-
-    @omnisci('int8[](int64, int32)')
-    def operator_gt(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a > v
-
-    @omnisci('bool(int64, int32)')
-    def operator_gt_array(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a > a
-
-    @omnisci('int32[](int64)')
-    def operator_iadd(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(1)
-        operator.iadd(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_iand(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.iand(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_ifloordiv(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i+10)
-            b[i] = nb_types.int32(i+3)
-        operator.ifloordiv(a, b)
-        return a
-
-    @omnisci('double[](int64)')
-    def operator_ifloordiv2(size):
-        a = Array(size, 'double')
-        b = Array(size, 'double')
-        for i in range(size):
-            a[i] = nb_types.double(i+10)
-            b[i] = nb_types.double(i+3)
-        operator.ifloordiv(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_ilshift(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.ilshift(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_imul(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.imul(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_ior(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.ior(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_isub(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.isub(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_ipow(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i+1)
-            b[i] = nb_types.int32(size-i)
-        operator.ipow(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_irshift(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.irshift(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_itruediv(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i+10)
-            b[i] = nb_types.int32(i+3)
-        operator.itruediv(a, b)
-        return a
-
-    @omnisci('double[](int64)')
-    def operator_itruediv2(size):
-        a = Array(size, 'double')
-        b = Array(size, 'double')
-        for i in range(size):
-            a[i] = nb_types.double(i+10)
-            b[i] = nb_types.double(i+3)
-        operator.itruediv(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_imod(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i * 123)
-            b[i] = nb_types.int32(7)
-        operator.imod(a, b)
-        return a
-
-    @omnisci('int32[](int64)')
-    def operator_ixor(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        operator.ixor(a, b)
-        return a
-
-    @omnisci('int8(int64, int32)')
-    def operator_in(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return v in a
-
-    @omnisci('int8(int64, int32)')
-    def operator_is(size, v):
-        a = Array(size, 'int32')
-        a.fill(v)
-        return a is a
-
-    @omnisci('int8(int64, int32)')
-    def operator_is_not(size, v):
-        a = Array(size, 'int32')
-        a.fill(v)
-        return a is not a
-
-    @omnisci('int8(int64, int32)')
-    def operator_is_not2(size, v):
-        a = Array(size, 'int32')
-        a.fill(v)
-        b = Array(size, 'int32')
-        b.fill(v)
-        return a is not b
-
-    @omnisci('int8[](int64, int32)')
-    def operator_le(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a <= v
-
-    @omnisci('bool(int64, int32)')
-    def operator_le_array(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a <= a
-
-    @omnisci('int32[](int64)')
-    def operator_lshift(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.lshift(a, b)
-
-    @omnisci('int8[](int64, int32)')
-    def operator_lt(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a < v
-
-    @omnisci('bool(int64, int32)')
-    def operator_lt_array(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a < a
-
-    @omnisci('int32[](int64)')
-    def operator_mul(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.mul(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_mod(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i * 123)
-            b[i] = nb_types.int32(7)
-        return operator.mod(a, b)
-
-    @omnisci('int8[](int64, int32)')
-    def operator_ne(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a != v
-
-    @omnisci('bool(int64, int32)')
-    def operator_ne_array(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return a != a
-
-    @omnisci('int32[](int64)')
-    def operator_neg(size):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return operator.neg(a)
-
-    @omnisci('int8(int64, int32)')
-    def operator_not_in(size, v):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-        return v not in a
-
-    @omnisci('int32[](int64)')
-    def operator_or_bw(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.or_(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_pos(size):
-        a = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(-i)
-        return operator.pos(a)
-
-    @omnisci('int32[](int64)')
-    def operator_pow(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i+1)
-            b[i] = nb_types.int32(size-i)
-        return operator.pow(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_rshift(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.rshift(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_sub(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.sub(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_truediv(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i+10)
-            b[i] = nb_types.int32(i+3)
-        return operator.truediv(a, b)
-
-    @omnisci('double[](int64)')
-    def operator_truediv2(size):
-        a = Array(size, 'double')
-        b = Array(size, 'double')
-        for i in range(size):
-            a[i] = nb_types.double(i+10)
-            b[i] = nb_types.double(i+3)
-        return operator.truediv(a, b)
-
-    @omnisci('int32[](int64)')
-    def operator_xor(size):
-        a = Array(size, 'int32')
-        b = Array(size, 'int32')
-        for i in range(size):
-            a[i] = nb_types.int32(i)
-            b[i] = nb_types.int32(size-i-1)
-        return operator.xor(a, b)
+        res = abs(a)
+        a.free()
+        return res
+
+    print()
+    print('*' * 80)
+    print('LLVM IR DUMP of operator_abs')
+    print(operator_abs.describe())
+    print('*' * 80)
+    print()
+
+    # @omnisci('int32[](int64)')
+    # def operator_add(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.add(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_and_bw(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.and_(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int64(int64, int64, int64)')
+    # def operator_countOf(size, fill_value, b):
+    #     a = Array(size, 'int64')
+    #     for i in range(size):
+    #         a[i] = fill_value
+    #     res = operator.countOf(a, b)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int8[](int64, int32)')
+    # def operator_eq(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a == v)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('bool(int64, int32)')
+    # def operator_eq_array(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a == a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_floordiv(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i+10)
+    #         b[i] = nb_types.int32(i+3)
+    #     res = operator.floordiv(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('double[](int64)')
+    # def operator_floordiv2(size):
+    #     a = Array(size, 'double')
+    #     b = Array(size, 'double')
+    #     for i in range(size):
+    #         a[i] = nb_types.double(i+10)
+    #         b[i] = nb_types.double(i+3)
+    #     res = operator.floordiv(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int8[](int64, int32)')
+    # def operator_ge(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a >= v)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('bool(int64, int32)')
+    # def operator_ge_array(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a >= a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int8[](int64, int32)')
+    # def operator_gt(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a > v)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('bool(int64, int32)')
+    # def operator_gt_array(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a > a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_iadd(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(1)
+    #     operator.iadd(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_iand(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.iand(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_ifloordiv(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i+10)
+    #         b[i] = nb_types.int32(i+3)
+    #     operator.ifloordiv(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('double[](int64)')
+    # def operator_ifloordiv2(size):
+    #     a = Array(size, 'double')
+    #     b = Array(size, 'double')
+    #     for i in range(size):
+    #         a[i] = nb_types.double(i+10)
+    #         b[i] = nb_types.double(i+3)
+    #     operator.ifloordiv(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_ilshift(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.ilshift(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_imul(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.imul(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_ior(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.ior(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_isub(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.isub(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_ipow(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i+1)
+    #         b[i] = nb_types.int32(size-i)
+    #     operator.ipow(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_irshift(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.irshift(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_itruediv(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i+10)
+    #         b[i] = nb_types.int32(i+3)
+    #     operator.itruediv(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('double[](int64)')
+    # def operator_itruediv2(size):
+    #     a = Array(size, 'double')
+    #     b = Array(size, 'double')
+    #     for i in range(size):
+    #         a[i] = nb_types.double(i+10)
+    #         b[i] = nb_types.double(i+3)
+    #     operator.itruediv(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_imod(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i * 123)
+    #         b[i] = nb_types.int32(7)
+    #     operator.imod(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int32[](int64)')
+    # def operator_ixor(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     operator.ixor(a, b)
+    #     # b.free()
+    #     return a
+
+    # @omnisci('int8(int64, int32)')
+    # def operator_in(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (v in a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int8(int64, int32)')
+    # def operator_is(size, v):
+    #     a = Array(size, 'int32')
+    #     a.fill(v)
+    #     res = (a is a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int8(int64, int32)')
+    # def operator_is_not(size, v):
+    #     a = Array(size, 'int32')
+    #     a.fill(v)
+    #     res = (a is not a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int8(int64, int32)')
+    # def operator_is_not2(size, v):
+    #     a = Array(size, 'int32')
+    #     a.fill(v)
+    #     b = Array(size, 'int32')
+    #     b.fill(v)
+    #     res = (a is not b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int8[](int64, int32)')
+    # def operator_le(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a <= v)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('bool(int64, int32)')
+    # def operator_le_array(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a <= a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_lshift(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.lshift(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int8[](int64, int32)')
+    # def operator_lt(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a < v)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('bool(int64, int32)')
+    # def operator_lt_array(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a < a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_mul(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.mul(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_mod(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i * 123)
+    #         b[i] = nb_types.int32(7)
+    #     res = operator.mod(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int8[](int64, int32)')
+    # def operator_ne(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a != v)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('bool(int64, int32)')
+    # def operator_ne_array(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (a != a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_neg(size):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = operator.neg(a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int8(int64, int32)')
+    # def operator_not_in(size, v):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #     res = (v not in a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_or_bw(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.or_(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_pos(size):
+    #     a = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(-i)
+    #     res = operator.pos(a)
+    #     # a.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_pow(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i+1)
+    #         b[i] = nb_types.int32(size-i)
+    #     res = operator.pow(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_rshift(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.rshift(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_sub(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.sub(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_truediv(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i+10)
+    #         b[i] = nb_types.int32(i+3)
+    #     res = operator.truediv(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('double[](int64)')
+    # def operator_truediv2(size):
+    #     a = Array(size, 'double')
+    #     b = Array(size, 'double')
+    #     for i in range(size):
+    #         a[i] = nb_types.double(i+10)
+    #         b[i] = nb_types.double(i+3)
+    #     res = operator.truediv(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
+
+    # @omnisci('int32[](int64)')
+    # def operator_xor(size):
+    #     a = Array(size, 'int32')
+    #     b = Array(size, 'int32')
+    #     for i in range(size):
+    #         a[i] = nb_types.int32(i)
+    #         b[i] = nb_types.int32(size-i-1)
+    #     res = operator.xor(a, b)
+    #     # a.free()
+    #     # b.free()
+    #     return res
 
 
 @pytest.mark.parametrize("suffix, args, expected", operator_methods,
diff --git a/rbc/tests/test_omnisci_caller.py b/rbc/tests/test_omnisci_caller.py
index 1a680da0..5ea497d9 100644
--- a/rbc/tests/test_omnisci_caller.py
+++ b/rbc/tests/test_omnisci_caller.py
@@ -37,7 +37,7 @@ def aincr(x, dx, y):
             y[i] = x[i] + dx
         return size
 
-    @omnisci('Bytes(Bytes)')
+    @omnisci('Bytes(Bytes)', on_missing_free='ignore')
     def myupper(s):
         r = Bytes(len(s))
         for i in range(len(s)):
diff --git a/rbc/tests/test_omnisci_text.py b/rbc/tests/test_omnisci_text.py
index fb506dfc..f021257f 100644
--- a/rbc/tests/test_omnisci_text.py
+++ b/rbc/tests/test_omnisci_text.py
@@ -11,7 +11,7 @@
 def omnisci():
     # TODO: use omnisci_fixture from rbc/tests/__init__.py
     config = rbc_omnisci.get_client_config(debug=not True)
-    m = rbc_omnisci.RemoteOmnisci(**config)
+    m = rbc_omnisci.RemoteOmnisci(on_missing_free='fail', **config)
     table_name = os.path.splitext(os.path.basename(__file__))[0]
 
     m.sql_execute(f'DROP TABLE IF EXISTS {table_name}')
@@ -103,7 +103,7 @@ def test_bytes_return(omnisci):
 
     from rbc.omnisci_backend import Bytes
 
-    @omnisci('Bytes(int32, int32)')
+    @omnisci('Bytes(int32, int32)', on_missing_free='ignore')
     def make_abc(first, n):
         r = Bytes(n)
         for i in range(n):
@@ -122,7 +122,7 @@ def test_bytes_upper(omnisci):
 
     from rbc.omnisci_backend import Bytes
 
-    @omnisci('Bytes(Bytes)')
+    @omnisci('Bytes(Bytes)', on_missing_free='ignore')
     def myupper(s):
         r = Bytes(len(s))
         for i in range(len(s)):