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)
