def test_br_01(self): context = ip.Context() realtype = context.mk_real_type() limit = context.mk_number("50", realtype) one = context.mk_number("1", realtype) counter1 = context.mk_latch("counter1", realtype) plusone = context.mk_add(counter1, one) context.set_latch_init_next(counter1, one, plusone) counter2 = context.mk_latch("counter2", realtype) plusone = context.mk_add(counter2, one) context.set_latch_init_next(counter2, one, plusone) mul = context.mk_mul(counter1, counter2) context.mk_output(mul) target = context.mk_leq(limit, mul) br = context.mk_backward_reach() br.add_target(target) br.add_watch(counter1) br.add_watch(counter2) result = br.reach_targets() self.assertEquals(EngineResult.REACHABLE, result) trace = br.get_last_trace() traceDict = trace.get_as_net_dictionary() counter1lastValue = traceDict[counter1][-1] counter2lastValue = traceDict[counter2][-1] self.assertEquals(counter1lastValue, "8.0") self.assertEquals(counter2lastValue, "8.0")
def test_bmc_04(self): context = ip.Context() bt = context.mk_boolean_type() f = context.mk_false() t = context.mk_true() l1 = context.mk_latch('l1', bt) l2 = context.mk_latch('l2', bt) l3 = context.mk_latch('l3', bt) context.set_latch_init_next(l1, t, l3) context.set_latch_init_next(l2, f, l1) context.set_latch_init_next(l3, f, l2) bmc = context.mk_bmc() bmc.add_target(l3) bmc.add_watch(l1) bmc.add_watch(l2) bmc.add_watch(l3) bmc.set_current_depth(0) result = bmc.reach_targets() self.assertEquals(EngineResult.UNREACHABLE, result) bmc.set_current_depth(1) result = bmc.reach_targets() self.assertEquals(EngineResult.UNREACHABLE, result) bmc.set_current_depth(2) result = bmc.reach_targets() self.assertEquals(EngineResult.REACHABLE, result)
def doMain(): ctx = ip.Context() myTrafficLight = traffic_light.SimulinkCircuit(ctx, 'MyTrafficLight') myTrafficLight.mk_circuit() lightOut = myTrafficLight.outputs['traffic_light/out'] targetGreen = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Green'], 'Green') targetYellow = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Yellow'], 'Yellow') targetRed = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Red'], 'Red') targetOff = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Off'], 'Off') bmc = ctx.mk_bmc() bmc.add_target(targetGreen) bmc.add_target(targetYellow) bmc.add_target(targetRed) bmc.add_target(targetOff) for depth in range(4): bmc.set_current_depth(depth) res = bmc.reach_targets() if res == EngineResult.REACHABLE: reachedTargets = bmc.get_last_reached_targets() print 'Targets reached at depth', depth, ':' for target in reachedTargets: print '-->', ctx.net2name[target], '<--' trace = bmc.get_last_trace() traceDf = trace.get_as_dataframe(ctx.net2name) print traceDf # ip.plots.plot_counterexample_dictionary(cexDict) else: print 'No target reacheable at depth:', depth print
def doMain(): ctx = intrepyd.Context() circ = it.translate_simulink('example1.slx', 'float') decisions = {'example1/O1': ['A', 'B', 'C']} dec2tables, dec2indpairs, _ = mcdc.compute_mcdc(ctx, circ.SimulinkCircuit, decisions, 0) dec2df = mcdc.get_tables_as_dataframe(dec2tables) print dec2df['example1/O1'] print utils.pretty_print_ind_pair(dec2indpairs['example1/O1'])
def doMain(): ctx = intrepyd.Context() circ = it.translate_lustre('example4.lus', 'top', 'float32') decisions = {'d': ['a', 'b', 'c']} dec2tables, dec2indpairs, _ = mcdc.compute_mcdc(ctx, circ.LustreCircuit, decisions, 0) dec2df = mcdc.get_tables_as_dataframe(dec2tables) print dec2df['d'] print utils.pretty_print_ind_pair(dec2indpairs['d'])
def test_atg_01(self): ctx = ip.Context() decisions = {'O': ['A', 'B']} tables, decision2unreachable = ip.atg.compute_mcdc(ctx, CircAnd, decisions, maxDepth=10) decision2dataframe = ip.atg.get_tables_as_dataframe(tables) self.assertEqual(3, len(decision2dataframe['O'])) self.assertEqual(0, len(decision2unreachable['O']))
def test_engine_01(self): ctx = intrepyd.Context() bmc = ctx.mk_bmc() br = ctx.mk_backward_reach() bmcOpt = ctx.mk_optimizing_bmc() self.assertEqual(False, bmc.can_prove()) self.assertEqual(False, bmc.can_optimize()) self.assertEqual(True, br.can_prove()) self.assertEqual(False, br.can_optimize()) self.assertEqual(False, bmcOpt.can_prove()) self.assertEqual(True, bmcOpt.can_optimize())
def test_bmc_01(self): context = ip.Context() bt = context.mk_boolean_type() x = context.mk_input("x", bt) y = context.mk_input("y", bt) gate = context.mk_and(x, y) context.mk_output(gate) bmc = context.mk_bmc() bmc.add_target(gate) bmc.set_current_depth(0) result = bmc.reach_targets() self.assertEquals(EngineResult.REACHABLE, result)
def test_br_03(self): context = ip.Context() rt = context.mk_real_type() x = context.mk_input("x", rt) y = context.mk_input("y", rt) mul = context.mk_mul(x, y) mul = context.mk_mul(mul, y) n70 = context.mk_number('70', rt) lt = context.mk_lt(n70, mul) br = context.mk_backward_reach() br.add_target(lt) result = br.reach_targets() self.assertEquals(EngineResult.REACHABLE, result)
def test_simulator_01(self): ctx = ip.Context() bt = ctx.mk_boolean_type() x = ctx.mk_input('x', bt) y = ctx.mk_input('y', bt) x_and_y = ctx.mk_and(x, y) tr = ctx.mk_trace() tr.set_value(x, 0, 'true') tr.set_value(y, 0, 'true') sim = ctx.mk_simulator() sim.add_watch(x_and_y) sim.simulate(tr, 0) self.assertEqual( 1, ip.trace.Trace.get_numeric_value(tr.get_value(x_and_y, 0)))
def test_circuit_01(self): ctx = intrepyd.Context() inst1 = MyCirc(ctx, 'mycirc1') inst2 = MyCirc(ctx, 'mycirc2') bt = ctx.mk_boolean_type() i1 = ctx.mk_input('i1', bt) i2 = ctx.mk_input('i2', bt) inputs = { 'i1' : i1, 'i2' : i2 } out1 = inst1.mk_naked_circuit(inputs, True) out2 = inst2.mk_naked_circuit(inputs, True) diff = ctx.mk_xor(out1, out2) bmc = ctx.mk_bmc() bmc.add_target(diff) result = bmc.reach_targets() self.assertEqual(EngineResult.UNREACHABLE, result)
def test_exactly_one_09(self): context = ip.Context() nets = [] bt = context.mk_boolean_type() i1 = context.mk_input("i1", bt) i2 = context.mk_input("i2", bt) i3 = context.mk_input("i3", bt) nets.append(context.mk_or(i1, i2)) nets.append(context.mk_or(i1, i3)) nets.append(context.mk_or(i2, i3)) eo = ip.pseudoboolean.mk_exactly_one(context.ctx, nets, "eo") bmc = context.mk_bmc() bmc.add_target(eo) result = bmc.reach_targets() self.assertEqual(EngineResult.UNREACHABLE, result)
def test_bmc_02(self): context = ip.Context() bt = context.mk_boolean_type() x = context.mk_input("x", bt) y = context.mk_input("y", bt) gate = context.mk_and(x, y) context.mk_output(gate) bmc = context.mk_bmc() bmc.add_target(gate) bmc.set_current_depth(0) result = bmc.reach_targets() self.assertEquals(EngineResult.REACHABLE, result) trace = bmc.get_last_trace() self.assertEquals( 1, ip.trace.Trace.get_numeric_value(trace.get_value(x, 0))) self.assertEquals( 1, ip.trace.Trace.get_numeric_value(trace.get_value(y, 0)))
def test_simulator_02(self): ctx = ip.Context() it = ctx.mk_int8_type() x = ctx.mk_input('x', it) counter = ctx.mk_latch('counter', it) init = ctx.mk_number('0', it) next_ = ctx.mk_add(counter, x) ctx.set_latch_init_next(counter, init, next_) tr = ctx.mk_trace() tr.set_value(x, 0, '1') tr.set_value(x, 1, '3') sim = ctx.mk_simulator() sim.add_watch(counter) sim.simulate(tr, 2) self.assertEqual('0', tr.get_value(counter, 0)) self.assertEqual('1', tr.get_value(counter, 1)) self.assertEqual('4', tr.get_value(counter, 2))
def doMain(): ctx = intrepyd.Context() circ = it.translate_simulink('example2.slx', 'float') decisions = { 'example2/O1': ['A', 'B', 'C'], 'example2/O2': ['A', 'B', 'C', 'D'], 'example2/O3': ['C', 'D'] } dec2tables, dec2indpairs, _ = mcdc.compute_mcdc(ctx, circ.SimulinkCircuit, decisions, 0) dec2df = mcdc.get_tables_as_dataframe(dec2tables) for decision, df in dec2df.iteritems(): print 'MC/DC table for', decision print df print print 'Independence pairs for', decision utils.pretty_print_ind_pair(dec2indpairs[decision]) print
def test_bmc_05(self): context = ip.Context() bt = context.mk_boolean_type() x = context.mk_input("x", bt) y = context.mk_input("y", bt) target1 = context.mk_and(x, y) target2 = context.mk_and(context.mk_not(x), y) bmc = context.mk_bmc() bmc.add_target(target1) bmc.add_target(target2) result = bmc.reach_targets() self.assertEquals(EngineResult.REACHABLE, result) self.assertEquals(1, len(list(bmc.get_last_reached_targets()))) bmc.remove_last_reached_targets() result = bmc.reach_targets() self.assertEquals(EngineResult.REACHABLE, result) self.assertEquals(1, len(list(bmc.get_last_reached_targets()))) bmc.remove_last_reached_targets()
def test_trace_01(self): ctx = intrepyd.Context() tr = ctx.mk_trace() i0 = ctx.mk_input('i0', ctx.mk_boolean_type()) i1 = ctx.mk_input('i1', ctx.mk_boolean_type()) i2 = ctx.mk_input('i2', ctx.mk_int8_type()) i3 = ctx.mk_input('i3', ctx.mk_int16_type()) i4 = ctx.mk_input('i4', ctx.mk_int32_type()) i5 = ctx.mk_input('i5', ctx.mk_uint8_type()) i6 = ctx.mk_input('i6', ctx.mk_uint16_type()) i7 = ctx.mk_input('i7', ctx.mk_uint32_type()) i8 = ctx.mk_input('i8', ctx.mk_real_type()) tr.set_value(i0, 0, 'F') tr.set_value(i1, 0, 'T') tr.set_value(i2, 0, '1') tr.set_value(i3, 0, '2') tr.set_value(i4, 0, '3') tr.set_value(i5, 0, '4') tr.set_value(i6, 0, '5') tr.set_value(i7, 0, '6') tr.set_value(i8, 0, '7.0') self.assertEqual('F', tr.get_value(i0, 0)) self.assertEqual('T', tr.get_value(i1, 0)) self.assertEqual('1', tr.get_value(i2, 0)) self.assertEqual('2', tr.get_value(i3, 0)) self.assertEqual('3', tr.get_value(i4, 0)) self.assertEqual('4', tr.get_value(i5, 0)) self.assertEqual('5', tr.get_value(i6, 0)) self.assertEqual('6', tr.get_value(i7, 0)) self.assertEqual('7.0', tr.get_value(i8, 0)) nv = intrepyd.trace.Trace.get_numeric_value self.assertEqual(0, nv(tr.get_value(i0, 0))) self.assertEqual(1, nv(tr.get_value(i1, 0))) self.assertEqual(1, nv(tr.get_value(i2, 0))) self.assertEqual(2, nv(tr.get_value(i3, 0))) self.assertEqual(3, nv(tr.get_value(i4, 0))) self.assertEqual(4, nv(tr.get_value(i5, 0))) self.assertEqual(5, nv(tr.get_value(i6, 0))) self.assertEqual(6, nv(tr.get_value(i7, 0))) self.assertEqual(7.0, nv(tr.get_value(i8, 0))) df = tr.get_as_dataframe(ctx.net2name) self.assertEqual('F', df[0][0]) dd = tr.get_as_depth_dictionary() nd = tr.get_as_net_dictionary(ctx.net2name)
def test_scr_01(self): ctx = ip.Context() myTrafficLight = traffic_light.SimulinkCircuit(ctx, 'MyTrafficLight') myTrafficLight.mk_circuit() lightOut = myTrafficLight.outputs['traffic_light/out'] targetGreen = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Green'], 'Green') targetYellow = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Yellow'], 'Yellow') targetRed = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Red'], 'Red') targetOff = ctx.mk_eq(lightOut, myTrafficLight.nets['traffic_light/Off'], 'Off') bmc = ctx.mk_bmc() bmc.add_target(targetGreen) bmc.add_target(targetYellow) bmc.add_target(targetRed) bmc.add_target(targetOff) bmc.set_current_depth(4) res = bmc.reach_targets() self.assertEquals(res, EngineResult.REACHABLE) reachedTargets = list(bmc.get_last_reached_targets()) self.assertEquals(1, len(reachedTargets))
def test_counter_01(self): ctx = ip.Context() int8type = ctx.mk_int8_type() ten = ctx.mk_number("10", int8type) counter, Q = ip.components.mk_counter(ctx, "counter", type=int8type, limit=ten) simulator = ctx.mk_simulator() tr = ctx.mk_trace() simulator.add_watch(counter) simulator.add_watch(Q) simulator.simulate(tr, 12) self.assertEqual('9', tr.get_value(counter, 9)) self.assertEqual('F', tr.get_value(Q, 9)) self.assertEqual('10', tr.get_value(counter, 10)) self.assertEqual('T', tr.get_value(Q, 10)) self.assertEqual('10', tr.get_value(counter, 11)) self.assertEqual('T', tr.get_value(Q, 11))
def test_scr_02(self): ctx = ip.Context() myA7E = A7E_requirements.SimulinkCircuit(ctx, 'A7E_requirements') myA7E.mk_circuit() navigationUpdateMode = myA7E.nets['A7E_requirements/NU/Mode'] weaponDeliveryMode = myA7E.nets['A7E_requirements/WD/Mode'] aflyUpdate = myA7E.nets['A7E_requirements/NU/AflyUpd'] boc = myA7E.nets['A7E_requirements/WD/BOC'] sboc = myA7E.nets['A7E_requirements/WD/SBOC'] navAfly = ctx.mk_neq(navigationUpdateMode, aflyUpdate) wpnBoc = ctx.mk_eq(weaponDeliveryMode, boc) wpnSboc = ctx.mk_eq(weaponDeliveryMode, sboc) target1 = ctx.mk_and(navAfly, wpnBoc) target2 = ctx.mk_and(navAfly, wpnSboc) target = ctx.mk_or(target1, target2) wdm = myA7E.nets['A7E_requirements/WD/Mode'] num = myA7E.nets['A7E_requirements/NU/Mode'] br = ctx.mk_backward_reach() br.add_target(target) result = br.reach_targets() self.assertEquals(EngineResult.UNREACHABLE, result)
import pandas as pd class CircAnd(ip.circuit.Circuit): def __init__(self, ctx, name): ip.circuit.Circuit.__init__(self, ctx, name) def _mk_inputs(self): self.inputs['A'] = ctx.mk_input('A', ctx.mk_boolean_type()) self.inputs['B'] = ctx.mk_input('B', ctx.mk_boolean_type()) def _mk_naked_circuit_impl(self, inputs): n1 = self.inputs['A'] n2 = self.inputs['B'] outputs = collections.OrderedDict() out = ctx.mk_and(n1, n2) outputs['O'] = out self.nets['A'] = n1 self.nets['B'] = n2 self.nets['O'] = out return outputs if __name__ == "__main__": ctx = ip.Context() decisions = {'O': ['A', 'B']} tables, _ = ip.atg.compute_mcdc(ctx, CircAnd, decisions, maxDepth=10) decision2dataframe = ip.atg.get_tables_as_dataframe(tables) if len(decision2dataframe) != 0: print '\nGenerated tests:' print decision2dataframe['O']
def test_exactly_one_08(self): context = ip.Context() self.create_and_run_nets(43, context)