intrepyd 0.13.0__py3-none-win_amd64.whl

intrepyd/LICENSE.intrepid

@@ -0,0 +1,60 @@
+Intrepid Proprietary License
+
+Copyright (c) 2016-2026 Roberto Bruttomesso
+All rights reserved.
+
+This license applies to the contents of the Intrepid repository and all of
+its subdirectories (the "Software"), including source code, build scripts,
+interface definitions, files generated from them, and any binary obtained by
+compiling them.
+
+1. No rights granted. The Software is the exclusive property of Roberto
+   Bruttomesso (the "Author"). Except as stated in section 7, or as expressly
+   authorized in advance and in writing by the Author, no permission is
+   granted to any person to use, run, copy, compile, modify, translate,
+   adapt, merge, publish, distribute, sublicense, sell, rent, lend, host, or
+   otherwise make available the Software, in whole or in part, nor to create
+   derivative works based on it.
+
+2. Explicit consent required. Any authorization must be given explicitly and
+   in writing by the Author, and is limited to the scope, duration, and
+   purpose stated in it. Authorization cannot be inferred from conduct, from
+   access to the Software, or from the Software being publicly visible.
+
+3. No reverse engineering. Decompiling, disassembling, or reverse engineering
+   any binary form of the Software is forbidden, except to the extent that
+   applicable law expressly permits it notwithstanding this restriction.
+
+4. Notices. Copyright and license notices in the Software must not be
+   removed or altered.
+
+5. Third party software. The Software is built against third party
+   components (such as Z3, googletest and nlohmann/json) that are downloaded
+   at build time and are not part of the Software. Those components remain
+   under their own licenses.
+
+6. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+   KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+
+7. Permission for intrepyd. As an exception to sections 1 and 2, the Author
+   grants everyone a free, worldwide, non-exclusive, royalty-free permission
+   to use, run, copy and redistribute the compiled libraries of the Software
+   (libintrepid.so, libintrepid.dylib, intrepid.dll, and their static
+   counterparts), for any purpose, including commercial ones, provided that:
+
+   a. they are used as part of the intrepyd project
+      (https://github.com/formalmethods/intrepyd, and the "intrepyd"
+      package on PyPI), or of a modified version of it, through the
+      interfaces intrepyd provides;
+
+   b. they are redistributed unmodified, and together with this license.
+
+   This permission does not cover the source code of the Software, nor using
+   the libraries on their own, outside of intrepyd. Section 3 still applies.
+
+Requests for authorization: roberto.bruttomesso@gmail.com

intrepyd/__init__.py

@@ -0,0 +1,4 @@
+"""
+Main package for Intrepyd
+"""
+from .context import Context

intrepyd/api.py

@@ -0,0 +1,236 @@
+"""
+Python binding of the intrepid backend.
+
+intrepid is a C library (libintrepid.so on Linux, intrepid.dll on Windows),
+built and released from its own repository. This module loads it with ctypes
+and exposes each function of its C API, src/api/Intrepid.h, under the same
+name, so that
+
+    from intrepyd.api import mk_ctx, mk_boolean_type
+
+behaves as it did with the SWIG extension this module replaces:
+
+- strings are passed and returned as str;
+- handles (contexts, types, engines, traces, simulators) are opaque values,
+  None when the library returns NULL; nets are ints;
+- an error reported by the library raises RuntimeError with its message.
+
+The library is looked up first in the INTREPID_LIBRARY environment variable,
+which must be the path of the library file, and then next to this module,
+which is where the packaged intrepyd ships it.
+"""
+
+import ctypes
+import os
+import sys
+
+__all__ = ['INT_ENGINE_RESULT_UNKNOWN', 'INT_ENGINE_RESULT_REACHABLE',
+           'INT_ENGINE_RESULT_UNREACHABLE', 'FUNCTIONS', 'LIBRARY_PATH']
+
+# intrepid is built for Linux and Windows only
+if sys.platform == 'win32':
+    _LIBRARY_NAME = 'intrepid.dll'
+else:
+    _LIBRARY_NAME = 'libintrepid.so'
+
+
+def _find_library():
+    path = os.environ.get('INTREPID_LIBRARY')
+    if path:
+        if not os.path.isfile(path):
+            raise ImportError('INTREPID_LIBRARY is set to %s, which is not a file' % path)
+        return path
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), _LIBRARY_NAME)
+    if not os.path.isfile(path):
+        raise ImportError(
+            'Cannot find the intrepid library %s. In a source checkout, run '
+            '"make fetch_intrepid", or point INTREPID_LIBRARY at a local build '
+            'of intrepid.' % path)
+    return path
+
+
+LIBRARY_PATH = _find_library()
+_lib = ctypes.CDLL(LIBRARY_PATH)
+
+# Values of the Int_engine_result enum
+INT_ENGINE_RESULT_UNKNOWN = 0
+INT_ENGINE_RESULT_REACHABLE = 1
+INT_ENGINE_RESULT_UNREACHABLE = 2
+
+# The C types used by the API
+HANDLE = ctypes.c_void_p    # Int_ctx, Int_type, Int_engine_*, Int_trace, ...
+UINT = ctypes.c_uint        # Int_net, unsigned
+INT = ctypes.c_int          # Int_engine_result
+STR = ctypes.c_char_p       # const char* argument, char* result
+CHAR = ctypes.c_char        # char result
+VOID = None
+
+# Every function of Intrepid.h, as name: (result type, argument types). It is
+# filled in by _bind, below, and checked against the header by
+# intrepyd/tests/test_api.py.
+FUNCTIONS = {}
+
+_check_exception = _lib.check_exception
+_check_exception.restype = STR
+_check_exception.argtypes = ()
+_clear_exception = _lib.clear_exception
+_clear_exception.restype = VOID
+_clear_exception.argtypes = ()
+FUNCTIONS['check_exception'] = (STR, ())
+FUNCTIONS['clear_exception'] = (VOID, ())
+__all__ += ['check_exception', 'clear_exception']
+
+
+def _encode(value):
+    return value.encode() if isinstance(value, str) else value
+
+
+def _bind(name, restype, argtypes):
+    FUNCTIONS[name] = (restype, argtypes)
+    __all__.append(name)
+    function = getattr(_lib, name)
+    function.restype = restype
+    function.argtypes = argtypes
+    string_args = [i for i, argtype in enumerate(argtypes) if argtype is STR]
+    decode = restype in (STR, CHAR)
+
+    # The library records an error rather than throwing, and the record stays
+    # until cleared: it is checked after each call, and cleared before raising
+    # so that the next call starts afresh.
+    def wrapper(*args):
+        if string_args:
+            args = list(args)
+            for i in string_args:
+                if i < len(args):
+                    args[i] = _encode(args[i])
+        result = function(*args)
+        error = _check_exception()
+        if error is not None:
+            _clear_exception()
+            raise RuntimeError(error.decode(errors='replace'))
+        if decode and result is not None:
+            return result.decode(errors='replace')
+        return result
+
+    wrapper.__name__ = name
+    wrapper.__qualname__ = name
+    return wrapper
+
+
+# check_exception and clear_exception are exposed as they are: wrapping them
+# would clear the very error they are asked about.
+def check_exception():
+    """Returns the message of the last error, or None if there was none"""
+    error = _check_exception()
+    return None if error is None else error.decode(errors='replace')
+
+
+def clear_exception():
+    """Forgets the last error"""
+    _clear_exception()
+
+
+mk_ctx = _bind('mk_ctx', HANDLE, ())
+del_ctx = _bind('del_ctx', VOID, (HANDLE,))
+throw_exception = _bind('throw_exception', VOID, (STR,))
+push_namespace = _bind('push_namespace', VOID, (HANDLE, STR))
+pop_namespace = _bind('pop_namespace', VOID, (HANDLE,))
+mk_engine_bmc = _bind('mk_engine_bmc', HANDLE, (HANDLE,))
+set_bmc_current_depth = _bind('set_bmc_current_depth', VOID, (HANDLE, UINT))
+set_bmc_optimize = _bind('set_bmc_optimize', VOID, (HANDLE,))
+set_bmc_allow_targets_at_any_depth = _bind('set_bmc_allow_targets_at_any_depth', VOID, (HANDLE,))
+set_bmc_use_induction = _bind('set_bmc_use_induction', VOID, (HANDLE,))
+set_bmc_use_attack_path_axioms = _bind('set_bmc_use_attack_path_axioms', VOID, (HANDLE, HANDLE, UINT, UINT))
+bmc_add_target = _bind('bmc_add_target', VOID, (HANDLE, HANDLE, UINT))
+bmc_add_watch = _bind('bmc_add_watch', VOID, (HANDLE, HANDLE, UINT))
+bmc_reach_targets = _bind('bmc_reach_targets', INT, (HANDLE,))
+bmc_remove_last_reached_targets = _bind('bmc_remove_last_reached_targets', VOID, (HANDLE,))
+bmc_last_reached_targets_number = _bind('bmc_last_reached_targets_number', UINT, (HANDLE,))
+bmc_last_reached_target = _bind('bmc_last_reached_target', UINT, (HANDLE, UINT))
+bmc_get_trace = _bind('bmc_get_trace', HANDLE, (HANDLE, HANDLE, UINT))
+mk_engine_br = _bind('mk_engine_br', HANDLE, (HANDLE,))
+br_add_target = _bind('br_add_target', VOID, (HANDLE, HANDLE, UINT))
+br_add_watch = _bind('br_add_watch', VOID, (HANDLE, HANDLE, UINT))
+br_reach_targets = _bind('br_reach_targets', INT, (HANDLE,))
+br_remove_last_reached_targets = _bind('br_remove_last_reached_targets', VOID, (HANDLE,))
+br_last_reached_targets_number = _bind('br_last_reached_targets_number', UINT, (HANDLE,))
+br_last_reached_target = _bind('br_last_reached_target', UINT, (HANDLE, UINT))
+br_get_trace = _bind('br_get_trace', HANDLE, (HANDLE, HANDLE, UINT))
+mk_engine_pdr = _bind('mk_engine_pdr', HANDLE, (HANDLE,))
+pdr_add_target = _bind('pdr_add_target', VOID, (HANDLE, HANDLE, UINT))
+pdr_add_watch = _bind('pdr_add_watch', VOID, (HANDLE, HANDLE, UINT))
+pdr_reach_targets = _bind('pdr_reach_targets', INT, (HANDLE,))
+pdr_remove_last_reached_targets = _bind('pdr_remove_last_reached_targets', VOID, (HANDLE,))
+pdr_last_reached_targets_number = _bind('pdr_last_reached_targets_number', UINT, (HANDLE,))
+pdr_last_reached_target = _bind('pdr_last_reached_target', UINT, (HANDLE, UINT))
+pdr_get_trace = _bind('pdr_get_trace', HANDLE, (HANDLE, HANDLE, UINT))
+trace_prepare_value_for_net = _bind('trace_prepare_value_for_net', UINT, (HANDLE, HANDLE, UINT, UINT))
+prepare_value_for_net = _bind('prepare_value_for_net', UINT, (HANDLE, UINT))
+value_at = _bind('value_at', CHAR, (UINT,))
+trace_get_max_depth = _bind('trace_get_max_depth', UINT, (HANDLE,))
+mk_trace = _bind('mk_trace', HANDLE, (HANDLE,))
+trace_set_value = _bind('trace_set_value', VOID, (HANDLE, HANDLE, UINT, UINT, STR))
+trace_get_watched_nets_number = _bind('trace_get_watched_nets_number', UINT, (HANDLE,))
+trace_get_watched_net = _bind('trace_get_watched_net', UINT, (HANDLE, UINT))
+mk_simulator = _bind('mk_simulator', HANDLE, (HANDLE,))
+simulator_add_watch = _bind('simulator_add_watch', VOID, (HANDLE, HANDLE, UINT))
+simulator_simulate = _bind('simulator_simulate', VOID, (HANDLE, HANDLE, UINT))
+mk_boolean_type = _bind('mk_boolean_type', HANDLE, (HANDLE,))
+mk_int8_type = _bind('mk_int8_type', HANDLE, (HANDLE,))
+mk_int16_type = _bind('mk_int16_type', HANDLE, (HANDLE,))
+mk_int32_type = _bind('mk_int32_type', HANDLE, (HANDLE,))
+mk_int64_type = _bind('mk_int64_type', HANDLE, (HANDLE,))
+mk_uint8_type = _bind('mk_uint8_type', HANDLE, (HANDLE,))
+mk_uint16_type = _bind('mk_uint16_type', HANDLE, (HANDLE,))
+mk_uint32_type = _bind('mk_uint32_type', HANDLE, (HANDLE,))
+mk_uint64_type = _bind('mk_uint64_type', HANDLE, (HANDLE,))
+mk_int_type = _bind('mk_int_type', HANDLE, (HANDLE,))
+mk_real_type = _bind('mk_real_type', HANDLE, (HANDLE,))
+mk_float16_type = _bind('mk_float16_type', HANDLE, (HANDLE,))
+mk_float32_type = _bind('mk_float32_type', HANDLE, (HANDLE,))
+mk_float64_type = _bind('mk_float64_type', HANDLE, (HANDLE,))
+mk_undef = _bind('mk_undef', UINT, (HANDLE,))
+mk_true = _bind('mk_true', UINT, (HANDLE,))
+mk_false = _bind('mk_false', UINT, (HANDLE,))
+mk_number = _bind('mk_number', UINT, (HANDLE, STR, HANDLE))
+mk_not = _bind('mk_not', UINT, (HANDLE, UINT))
+mk_and = _bind('mk_and', UINT, (HANDLE, UINT, UINT))
+mk_or = _bind('mk_or', UINT, (HANDLE, UINT, UINT))
+mk_xor = _bind('mk_xor', UINT, (HANDLE, UINT, UINT))
+mk_ite = _bind('mk_ite', UINT, (HANDLE, UINT, UINT, UINT))
+mk_iff = _bind('mk_iff', UINT, (HANDLE, UINT, UINT))
+mk_minus = _bind('mk_minus', UINT, (HANDLE, UINT))
+mk_add = _bind('mk_add', UINT, (HANDLE, UINT, UINT))
+mk_sub = _bind('mk_sub', UINT, (HANDLE, UINT, UINT))
+mk_mul = _bind('mk_mul', UINT, (HANDLE, UINT, UINT))
+mk_div = _bind('mk_div', UINT, (HANDLE, UINT, UINT))
+mk_mod = _bind('mk_mod', UINT, (HANDLE, UINT, UINT))
+mk_eq = _bind('mk_eq', UINT, (HANDLE, UINT, UINT))
+mk_leq = _bind('mk_leq', UINT, (HANDLE, UINT, UINT))
+mk_lt = _bind('mk_lt', UINT, (HANDLE, UINT, UINT))
+mk_geq = _bind('mk_geq', UINT, (HANDLE, UINT, UINT))
+mk_gt = _bind('mk_gt', UINT, (HANDLE, UINT, UINT))
+mk_neq = _bind('mk_neq', UINT, (HANDLE, UINT, UINT))
+mk_input = _bind('mk_input', UINT, (HANDLE, STR, HANDLE))
+mk_output = _bind('mk_output', VOID, (HANDLE, UINT))
+get_bit = _bind('get_bit', UINT, (HANDLE, UINT, UINT))
+set_bit = _bind('set_bit', UINT, (HANDLE, UINT, UINT, UINT))
+mk_assumption = _bind('mk_assumption', VOID, (HANDLE, UINT))
+push_assumption = _bind('push_assumption', VOID, (HANDLE, UINT))
+pop_assumption = _bind('pop_assumption', VOID, (HANDLE,))
+mk_latch = _bind('mk_latch', UINT, (HANDLE, STR, HANDLE))
+set_latch_init_next = _bind('set_latch_init_next', VOID, (HANDLE, UINT, UINT, UINT))
+mk_substitute = _bind('mk_substitute', UINT, (HANDLE, UINT, UINT, UINT))
+mk_cast_to_int8 = _bind('mk_cast_to_int8', UINT, (HANDLE, UINT))
+mk_cast_to_int16 = _bind('mk_cast_to_int16', UINT, (HANDLE, UINT))
+mk_cast_to_int32 = _bind('mk_cast_to_int32', UINT, (HANDLE, UINT))
+mk_cast_to_int64 = _bind('mk_cast_to_int64', UINT, (HANDLE, UINT))
+mk_cast_to_uint8 = _bind('mk_cast_to_uint8', UINT, (HANDLE, UINT))
+mk_cast_to_uint16 = _bind('mk_cast_to_uint16', UINT, (HANDLE, UINT))
+mk_cast_to_uint32 = _bind('mk_cast_to_uint32', UINT, (HANDLE, UINT))
+mk_cast_to_uint64 = _bind('mk_cast_to_uint64', UINT, (HANDLE, UINT))
+apitrace_dump_to_file = _bind('apitrace_dump_to_file', VOID, (STR,))
+apitrace_print_to_stdout = _bind('apitrace_print_to_stdout', VOID, ())
+apitrace_print_to_stderr = _bind('apitrace_print_to_stderr', VOID, ())
+
+_clear_exception()

intrepyd/atg/__init__.py

@@ -0,0 +1,3 @@
+"""
+Atg
+"""

intrepyd/atg/circuit.py

@@ -0,0 +1,33 @@
+"""
+Implementation of Circuit class for ATG
+"""
+class Circuit:
+    """
+    Abstract interface for a circuit to use for ATG
+    """
+    def __init__(self, ctx, name):
+        self._ctx = ctx
+        self._name = name
+
+    def mk_circuit(self):
+        """
+        Makes the circuit
+        """
+        self._ctx.push_namespace(self._name)
+        self._mk_circuit_impl()
+        self._ctx.pop_namespace()
+
+    def _mk_circuit_impl(self):
+        raise NotImplementedError('Should have implemented this')
+
+    def inputs(self):
+        """
+        Returns the dictionary of inputs
+        """
+        raise NotImplementedError('Should have implemented this')
+
+    def nets(self):
+        """
+        Returns the dictionary of nets
+        """
+        raise NotImplementedError('Should have implemented this')

intrepyd/atg/mcdc.py

@@ -0,0 +1,293 @@
+"""
+This module implements a toolbox for Automated Test Generation
+"""
+
+import pandas as pd
+from intrepyd.engine import EngineResult
+
+def compute_mcdc(context, class_, decisions, max_depth):
+    """
+    Computes MC/DC tests in form of a table.
+
+    Args:
+        context: the intrepyd context to use
+        class_ (class): a python class that defines the circuit
+        decisions (Dictionary): each key of the dictionary is the
+                    name of a decision, and the values are the
+                    corresponding conditions
+
+                { netName           : [netName, ...] }
+                  ^                    ^
+                  the decision         the list of conditions
+
+    Returns:
+        (Dictionary) the MC/DC tables, one per each decision
+    """
+
+    # Fetches and duplicates the circuit
+    inst_a = class_(context, 'InstA')
+    inst_b = class_(context, 'InstB')
+    inst_a.mk_circuit()
+    inst_b.mk_circuit()
+
+    # Creates test objectives
+    decision2testobjectives = {decision :\
+            compute_mcdc_targets(context, inst_a, inst_b, decision, conditions)\
+            for decision, conditions in decisions.items()}
+
+    # Compute MC/DC traces: this is the computationally
+    # expensive part that calls model checking routines
+    decision2traces, trace2condition, decision2unreachable =\
+            solve_mcdc_targets(context, decision2testobjectives, decisions, max_depth)
+
+    # Compute MC/DC tables from traces
+    decision2table, decision2independencepairs =\
+            compute_mcdc_tables(context, inst_a, inst_b,\
+                                decision2traces, trace2condition, decisions)
+
+    return decision2table, decision2independencepairs, decision2unreachable
+
+
+def compute_mcdc_targets(context, inst_a, inst_b, decision, conditions):
+    """
+    Computes the MC/DC reachability target for the
+    two copies of the circuit.
+
+    Args:
+        context: the intrepyd context to use
+        inst_a: an instance of the circuit
+        inst_b: an instance of the circuit
+        decision: the name of a decision
+        conditions: the list of names of the conditions
+
+    Returns:
+        a map from targets to conditions for which target is an independence pair
+    """
+    decision_a = inst_a.nets()[decision]
+    decision_b = inst_b.nets()[decision]
+    decisiona_diff_decisionb = context.mk_neq(decision_a, decision_b)
+
+    conditiona_neq_conditionb = []
+    conditions_a = []
+    conditions_b = []
+    for condition in conditions:
+        condition_a = inst_a.nets()[condition]
+        conditions_a.append(condition_a)
+        condition_b = inst_b.nets()[condition]
+        conditions_b.append(condition_b)
+        conditiona_neq_conditionb.append(context.mk_neq(condition_a, condition_b))
+
+    targets = {}
+    for i in range(len(conditions)):
+        # Building test objective for the i-th condition
+        condition_a = conditions_a[i]
+        condition_b = conditions_b[i]
+        # i-th condition must differ in A and B
+        conj1 = conditiona_neq_conditionb[i]
+        # test objective must differ in A and B
+        conj2 = decisiona_diff_decisionb
+        # decisionA[not(cA)/cA] != decisionA
+        not_condition_a = context.mk_not(condition_a)
+        decisiona_not_ca = context.mk_substitute(decision_a, not_condition_a, condition_a)
+        conj3 = context.mk_neq(decisiona_not_ca, decision_a)
+        # decisionB[not(cB)/cB] != decisionB
+        not_condition_b = context.mk_not(condition_b)
+        decisiona_not_cb = context.mk_substitute(decision_b, not_condition_b, condition_b)
+        conj4 = context.mk_neq(decisiona_not_cb, decision_b)
+        # Creates final conjunction
+        tmp1 = context.mk_and(conj1, conj2)
+        tmp2 = context.mk_and(tmp1, conj3)
+        target = context.mk_and(tmp2, conj4)
+        targets[target] = i
+
+    return targets
+
+
+def solve_mcdc_targets(context, decision2testobjectives, decisions, max_depth):
+    """
+    Solves the MC/DC targets, maximizing the number of solved
+    test objectives per each call.
+    """
+    # Bmc engine will be used to compute counterexamples
+    bmc = context.mk_optimizing_bmc()
+
+    testobjectives2decision = {}
+    testobjectives2condition = {}
+    decision2traces = {}
+    decision2unreachable = {}
+    targets = []
+    for decision, tos in decision2testobjectives.items():
+        decision2traces[decision] = []
+        decision2unreachable[decision] = []
+        for test_objective, condition in tos.items():
+            testobjectives2decision[test_objective] = decision
+            testobjectives2condition[test_objective] = condition
+            targets.append(test_objective)
+    assert len(testobjectives2decision) == len(testobjectives2condition)
+    total_targets = len(targets)
+
+    # Compute unreachable targets first
+    total_unreached = 0
+    total_reached = 0
+    for target in targets:
+        breach = context.mk_backward_reach()
+        breach.add_target(target)
+        result = breach.reach_targets()
+        if result == EngineResult.UNREACHABLE:
+            decision = testobjectives2decision[target]
+            condition = decision2testobjectives[decision][target]
+            condition = decisions[decision][condition]
+            decision2unreachable[decision].append(condition)
+
+            total_unreached += 1
+        elif result == EngineResult.REACHABLE:
+            bmc.add_target(target)
+            total_reached += 1
+
+    # print('There are', totalTargets, 'test objectives:')
+    # print('-', totalUnreached, 'unreachable test objectives')
+    # print('-', totalReached, 'reachable test objectives')
+    trace2condition = {}
+
+    if total_unreached == total_targets:
+        return decision2traces, trace2condition, decision2unreachable
+
+    # Compute counterexamples for reachable targets
+    done = False
+    depth = 0
+    bmc_total_reached = 0
+    while not done:
+        bmc.set_current_depth(depth)
+        result = bmc.reach_targets()
+        if result != EngineResult.REACHABLE:
+            if depth == max_depth:
+                done = True
+            depth += 1
+            continue
+        reached = bmc.get_last_reached_targets()
+        trace = bmc.get_last_trace()
+        for reached_target in reached:
+            decision = testobjectives2decision[reached_target]
+            decision2traces[decision].append(trace)
+            trace2condition[trace] = testobjectives2condition[reached_target]
+            bmc_total_reached += 1
+        bmc.remove_last_reached_targets()
+        if bmc_total_reached == total_reached:
+            done = True
+
+    total_undecided = total_reached - bmc_total_reached
+    if total_undecided != 0:
+        print('There are', total_undecided, 'undecided test objectives within depth', max_depth)
+
+    return decision2traces, trace2condition, decision2unreachable
+
+
+def compute_mcdc_tables(context, inst_a, inst_b, decision2traces, trace2condition, decisions):
+    """
+    Computes MC/DC tables out of counterexamples.
+    """
+    decision2table = {}
+    decision2independencepairs = {}
+    seen = {}
+    for decision, traces in decision2traces.items():
+        inst_a_conds_dec =\
+          [inst_a.nets()[cond] for cond in decisions[decision]] + [inst_a.nets()[decision]]
+        inst_a_testnets =\
+          list(inst_a.inputs().values()) + inst_a_conds_dec
+        inst_b_conds_dec =\
+          [inst_b.nets()[cond] for cond in decisions[decision]] + [inst_b.nets()[decision]]
+        inst_b_testnets = list(inst_b.inputs().values()) + inst_b_conds_dec
+        header = decisions[decision]
+        header.append(decision)
+        header_nets_a = set(inst_a_conds_dec)
+        # Enable this to include inputs in the tests (but you need to add also names in headers)
+        # header_nets_a = set(inst_a_testnets)
+        header_nets_b = set(inst_b_conds_dec)
+        # Enable this to include inputs in the tests (but you need to add also names in headers)
+        # header_nets_b = set(inst_b_testnets)
+        decision2table[decision] = [header]
+        decision2independencepairs[decision] = {}
+        test_number = 0
+        for trace in traces:
+            test_a_number = None
+            test_b_number = None
+            # Enrich the traces with the value of the output
+            # by performing a simulation
+            simulator = context.mk_simulator()
+            for net in inst_a_testnets:
+                simulator.add_watch(net)
+            for net in inst_b_testnets:
+                simulator.add_watch(net)
+            simulator.simulate(trace, trace.get_max_depth())
+            full_test_a = trace.get_as_net_dictionary()
+            full_test_b = trace.get_as_net_dictionary()
+            test_a_candidate = [v[0] for k, v in full_test_a.items()\
+                                  if (k in inst_a_testnets and k in header_nets_a)]
+            test_b_candidate = [v[0] for k, v in full_test_b.items()\
+                                  if (k in inst_b_testnets and k in header_nets_b)]
+            test_a_hash = compute_hash(test_a_candidate)
+            test_b_hash = compute_hash(test_b_candidate)
+
+            if test_a_hash in seen:
+                _, test_a_number = seen[test_a_hash]
+            else:
+                seen[test_a_hash] = (test_a_candidate, test_number)
+                decision2table[decision].append(test_a_candidate)
+                test_a_number = test_number
+                test_number += 1
+
+            if test_b_hash in seen:
+                _, test_b_number = seen[test_b_hash]
+            else:
+                seen[test_b_hash] = (test_b_candidate, test_number)
+                decision2table[decision].append(test_b_candidate)
+                test_b_number = test_number
+                test_number += 1
+
+            condition = trace2condition[trace]
+            condition = decisions[decision][condition]
+            decision2independencepairs[decision][condition] = (test_a_number, test_b_number)
+    return decision2table, decision2independencepairs
+
+
+def compute_hash(test):
+    """
+    Computes a unique hash for a test
+    """
+    result = ""
+    for val in test:
+        result += val
+    return result
+
+
+def compute_pretty_tables(decision2table):
+    """
+    Postprocess raw MC/DC tables to get something presentation ready.
+    """
+    decision2prettytable = {}
+    first = True
+    for decision, table in decision2table.items():
+        pretty_table = []
+        for row in table:
+            if first:
+                first = False
+                pretty_table.append(row)
+            else:
+                pretty_table.append(row[0])
+                pretty_table.append(row[1])
+        decision2prettytable[decision] = pretty_table
+    return decision2prettytable
+
+
+def get_tables_as_dataframe(decision2table):
+    """
+    Postprocess table to turn into a dataframe
+    """
+    result = {}
+    for decision, table in decision2table.items():
+        if len(table) == 1:
+            continue
+        dataframe = pd.DataFrame(table[1:], columns=table[0])
+        dataframe = dataframe.drop_duplicates()
+        result[decision] = dataframe
+    return result