def main(): slv = pycvc4.Solver() slv.setOption("produce-models", "true") # Setting an invalid option try: slv.setOption("non-existing", "true") return 1 except: pass # Creating a term with an invalid type try: integer = slv.getIntegerSort() x = slv.mkConst("x", integer) invalidTerm = em.mkTerm(AND, x, x) slv.checkSat(invalidTerm) return 1 except: pass # Asking for a model after unsat result try: slv.checkSat(slv.mkBoolean(False)) slv.getModel() return 1 except: pass return 0
def test_add_rules(): solver = pycvc4.Solver() boolean = solver.getBooleanSort() integer = solver.getIntegerSort() nullTerm = pycvc4.Term(solver) start = solver.mkVar(boolean) nts = solver.mkVar(boolean) g = solver.mkSygusGrammar([], [start]) g.addRules(start, {solver.mkBoolean(False)}) #Expecting errors with pytest.raises(Exception): g.addRules(nullTerm, solver.mkBoolean(False)) with pytest.raises(Exception): g.addRules(start, {nullTerm}) with pytest.raises(Exception): g.addRules(nts, {solver.mkBoolean(False)}) with pytest.raises(Exception): g.addRules(start, {solver.mkReal(0)}) #Expecting no errors solver.synthFun("f", {}, boolean, g) #Expecting an error with pytest.raises(Exception): g.addRules(start, solver.mkBoolean(False))
def testAddAnyVariable(): solver = pycvc4.Solver() boolean = solver.getBooleanSort() nullTerm = pycvc4.Term(solver) x = solver.mkVar(boolean) start = solver.mkVar(boolean) nts = solver.mkVar(boolean) g1 = solver.mkSygusGrammar({x}, {start}) g2 = solver.mkSygusGrammar({}, {start}) g1.addAnyVariable(start) g1.addAnyVariable(start) g2.addAnyVariable(start) with pytest.raises(Exception): g1.addAnyVariable(nullTerm) with pytest.raises(Exception): g1.addAnyVariable(nts) solver.synthFun("f", {}, boolean, g1) with pytest.raises(Exception): g1.addAnyVariable(start)
def testGetTupleSorts(): solver = pycvc4.Solver() tupleSort = solver.mkTupleSort([solver.getIntegerSort(), solver.getIntegerSort()]) tupleSort.getTupleSorts() bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): bvSort.getTupleSorts()
def testGetBVSize(): solver = pycvc4.Solver() bvSort = solver.mkBitVectorSort(32) bvSort.getBVSize() setSort = solver.mkSetSort(solver.getIntegerSort()) with pytest.raises(Exception): setSort.getBVSize()
def testIsUninterpretedSortParameterized(): solver = pycvc4.Solver() uSort = solver.mkUninterpretedSort("u") uSort.isUninterpretedSortParameterized() bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): bvSort.isUninterpretedSortParameterized()
def testGetUninterpretedSortParamSorts(): solver = pycvc4.Solver() uSort = solver.mkUninterpretedSort("u") uSort.getUninterpretedSortParamSorts() bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): bvSort.getUninterpretedSortParamSorts()
def testGetFPSignificandSize(): solver = pycvc4.Solver() fpSort = solver.mkFloatingPointSort(4, 8) fpSort.getFPSignificandSize() setSort = solver.mkSetSort(solver.getIntegerSort()) with pytest.raises(Exception): setSort.getFPSignificandSize()
def testGetUninterpretedSortConstructorArity(): solver = pycvc4.Solver() sSort = solver.mkSortConstructorSort("s", 2) sSort.getSortConstructorArity() bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): bvSort.getSortConstructorArity()
def testGetArrayElementSort(): solver = pycvc4.Solver() elementSort = solver.mkBitVectorSort(32) indexSort = solver.mkBitVectorSort(32) arraySort = solver.mkArraySort(indexSort, elementSort) arraySort.getArrayElementSort() with pytest.raises(Exception): indexSort.getArrayElementSort()
def testGetFunctionCodomainSort(): solver = pycvc4.Solver() funSort = solver.mkFunctionSort(solver.mkUninterpretedSort("u"), solver.getIntegerSort()) funSort.getFunctionCodomainSort() bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): bvSort.getFunctionCodomainSort()
def test_getitem(): solver = pycvc4.Solver() intsort = solver.getIntegerSort() x = solver.mkConst(intsort, 'x') y = solver.mkConst(intsort, 'y') xpy = solver.mkTerm(kinds.Plus, x, y) assert xpy[0] == x assert xpy[1] == y
def testGetSequenceElementSort(): solver = pycvc4.Solver() seqSort = solver.mkSequenceSort(solver.getIntegerSort()) seqSort.getSequenceElementSort() bvSort = solver.mkBitVectorSort(32) assert not bvSort.isSequence() with pytest.raises(Exception): bvSort.getSetElementSort()
def testGetString(): solver = pycvc4.Solver() s1 = '"test\n"😃\\u{a}' t1 = solver.mkString(s1) assert s1 == t1.toPythonObj() s2 = '❤️CVC4❤️' t2 = solver.mkString(s2) assert s2 == t2.toPythonObj()
def testGetReal(): solver = pycvc4.Solver() half = solver.mkReal("1/2") assert half.toPythonObj() == Fraction(1, 2) neg34 = solver.mkReal("-3/4") assert neg34.toPythonObj() == Fraction(-3, 4) neg1 = solver.mkInteger("-1") assert neg1.toPythonObj() == -1
def testSortCompare(): solver = pycvc4.Solver() boolSort = solver.getBooleanSort() intSort = solver.getIntegerSort() bvSort = solver.mkBitVectorSort(32) bvSort2 = solver.mkBitVectorSort(32) assert bvSort >= bvSort2 assert bvSort <= bvSort2 assert (intSort > boolSort) != (intSort < boolSort) assert (intSort > bvSort or intSort == bvSort) == (intSort >= bvSort)
def test_is_const(): solver = pycvc4.Solver() intsort = solver.getIntegerSort() one = solver.mkReal(1) x = solver.mkConst(intsort, 'x') xpone = solver.mkTerm(kinds.Plus, x, one) onepone = solver.mkTerm(kinds.Plus, one, one) assert not x.isConst() assert one.isConst() assert not xpone.isConst() assert not onepone.isConst()
def test_eq(): solver = pycvc4.Solver() usort = solver.mkUninterpretedSort('u') x = solver.mkConst(usort, 'x') y = solver.mkConst(usort, 'y') z = x assert x == x assert x == z assert not (x != x) assert x != y assert y != z
def testGetFPExponentSize(): solver = pycvc4.Solver() if solver.supportsFloatingPoint(): fpSort = solver.mkFloatingPointSort(4, 8) fpSort.getFPExponentSize() setSort = solver.mkSetSort(solver.getIntegerSort()) with pytest.raises(Exception): setSort.getFPExponentSize() else: with pytest.raises(Exception): solver.mkFloatingPointSort(4, 8)
def test_get_kind(): solver = pycvc4.Solver() intsort = solver.getIntegerSort() x = solver.mkConst(intsort, 'x') y = solver.mkConst(intsort, 'y') xpy = solver.mkTerm(kinds.Plus, x, y) assert xpy.getKind() == kinds.Plus funsort = solver.mkFunctionSort(intsort, intsort) f = solver.mkConst(funsort, 'f') assert f.getKind() == kinds.Constant fx = solver.mkTerm(kinds.ApplyUf, f, x) assert fx.getKind() == kinds.ApplyUf
def testGetArray(): solver = pycvc4.Solver() arrsort = solver.mkArraySort(solver.getRealSort(), solver.getRealSort()) zero_array = solver.mkConstArray(arrsort, solver.mkInteger(0)) stores = solver.mkTerm(kinds.Store, zero_array, solver.mkInteger(1), solver.mkInteger(2)) stores = solver.mkTerm(kinds.Store, stores, solver.mkInteger(2), solver.mkInteger(3)) stores = solver.mkTerm(kinds.Store, stores, solver.mkInteger(4), solver.mkInteger(5)) array_dict = stores.toPythonObj() assert array_dict[1] == 2 assert array_dict[2] == 3 assert array_dict[4] == 5 # an index that wasn't stored at should give zero assert array_dict[8] == 0
def testGetDatatypeArity(): solver = pycvc4.Solver() # create datatype sort, check should not fail dtypeSpec = solver.mkDatatypeDecl("list") cons = solver.mkDatatypeConstructorDecl("cons") cons.addSelector("head", solver.getIntegerSort()) dtypeSpec.addConstructor(cons) nil = solver.mkDatatypeConstructorDecl("nil") dtypeSpec.addConstructor(nil) dtypeSort = solver.mkDatatypeSort(dtypeSpec) dtypeSort.getDatatypeArity() # create bv sort, check should fail bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): bvSort.getDatatypeArity()
def test_get_sort(): solver = pycvc4.Solver() intsort = solver.getIntegerSort() bvsort8 = solver.mkBitVectorSort(8) x = solver.mkConst(intsort, 'x') y = solver.mkConst(intsort, 'y') a = solver.mkConst(bvsort8, 'a') b = solver.mkConst(bvsort8, 'b') assert x.getSort() == intsort assert solver.mkTerm(kinds.Plus, x, y).getSort() == intsort assert a.getSort() == bvsort8 assert solver.mkTerm(kinds.BVConcat, a, b).getSort() == solver.mkBitVectorSort(16)
def testGetDatatype(): solver = pycvc4.Solver() dtypeSpec = solver.mkDatatypeDecl("list") cons = solver.mkDatatypeConstructorDecl("cons") cons.addSelector("head", solver.getIntegerSort()) dtypeSpec.addConstructor(cons) nil = solver.mkDatatypeConstructorDecl("nil") dtypeSpec.addConstructor(nil) dtypeSort = solver.mkDatatypeSort(dtypeSpec) # expecting no Error dtypeSort.getDatatype() bvSort = solver.mkBitVectorSort(32) with pytest.raises(Exception): # expect an exception bvSort.getDatatype()
def testDatatypeSorts(): solver = pycvc4.Solver() intSort = solver.getIntegerSort() # create datatype sort to test dtypeSpec = solver.mkDatatypeDecl("list") cons = solver.mkDatatypeConstructorDecl("cons") cons.addSelector("head", intSort) cons.addSelectorSelf("tail") dtypeSpec.addConstructor(cons) nil = solver.mkDatatypeConstructorDecl("nil") dtypeSpec.addConstructor(nil) dtypeSort = solver.mkDatatypeSort(dtypeSpec) dt = dtypeSort.getDatatype() assert not dtypeSort.isConstructor() with pytest.raises(Exception): dtypeSort.getConstructorCodomainSort() with pytest.raises(Exception): dtypeSort.getConstructorDomainSorts() with pytest.raises(Exception): dtypeSort.getConstructorArity() # get constructor dcons = dt[0] consTerm = dcons.getConstructorTerm() consSort = consTerm.getSort() assert consSort.isConstructor() assert not consSort.isTester() assert not consSort.isSelector() assert consSort.getConstructorArity() == 2 consDomSorts = consSort.getConstructorDomainSorts() assert consDomSorts[0] == intSort assert consDomSorts[1] == dtypeSort assert consSort.getConstructorCodomainSort() == dtypeSort # get tester isConsTerm = dcons.getTesterTerm() assert isConsTerm.getSort().isTester() # get selector dselTail = dcons[1] tailTerm = dselTail.getSelectorTerm() assert tailTerm.getSort().isSelector()
def test_const_sequence_elements(): solver = pycvc4.Solver() realsort = solver.getRealSort() seqsort = solver.mkSequenceSort(realsort) s = solver.mkEmptySequence(seqsort) assert s.getKind() == kinds.ConstSequence # empty sequence has zero elements cs = s.getConstSequenceElements() assert len(cs) == 0 # A seq.unit app is not a constant sequence (regardless of whether it is # applied to a constant). su = solver.mkTerm(kinds.SeqUnit, solver.mkReal(1)) try: su.getConstSequenceElements() assert False except: assert True
def testSortSubtyping(): solver = pycvc4.Solver() intSort = solver.getIntegerSort() realSort = solver.getRealSort() assert intSort.isSubsortOf(realSort) assert not realSort.isSubsortOf(intSort) assert intSort.isComparableTo(realSort) assert realSort.isComparableTo(intSort) arraySortII = solver.mkArraySort(intSort, intSort) arraySortIR = solver.mkArraySort(intSort, realSort) assert not arraySortII.isComparableTo(intSort) # we do not support subtyping for arrays assert not arraySortII.isComparableTo(arraySortIR) setSortI = solver.mkSetSort(intSort) setSortR = solver.mkSetSort(realSort) # we support subtyping for sets assert setSortI.isSubsortOf(setSortR) assert setSortR.isComparableTo(setSortI)
def test_get_kind(): solver = pycvc4.Solver() intsort = solver.getIntegerSort() x = solver.mkConst(intsort, 'x') y = solver.mkConst(intsort, 'y') xpy = solver.mkTerm(kinds.Plus, x, y) assert xpy.getKind() == kinds.Plus funsort = solver.mkFunctionSort(intsort, intsort) f = solver.mkConst(funsort, 'f') assert f.getKind() == kinds.Constant fx = solver.mkTerm(kinds.ApplyUf, f, x) assert fx.getKind() == kinds.ApplyUf # Sequence kinds do not exist internally, test that the API properly # converts them back. seqsort = solver.mkSequenceSort(intsort) s = solver.mkConst(seqsort, 's') ss = solver.mkTerm(kinds.SeqConcat, s, s) assert ss.getKind() == kinds.SeqConcat
def test_get_op(): solver = pycvc4.Solver() intsort = solver.getIntegerSort() funsort = solver.mkFunctionSort(intsort, intsort) x = solver.mkConst(intsort, 'x') f = solver.mkConst(funsort, 'f') fx = solver.mkTerm(kinds.ApplyUf, f, x) assert not x.hasOp() try: op = x.getOp() assert False except: assert True assert fx.hasOp() assert fx.getOp().getKind() == kinds.ApplyUf # equivalent check assert fx.getOp() == solver.mkOp(kinds.ApplyUf)
def testAddAnyConstant(): solver = pycvc4.Solver() boolean = solver.getBooleanSort() nullTerm = pycvc4.Term(solver) start = solver.mkVar(boolean) nts = solver.mkVar(boolean) g = solver.mkSygusGrammar({}, {start}) g.addAnyConstant(start) g.addAnyConstant(start) with pytest.raises(Exception): g.addAnyConstant(nullTerm) with pytest.raises(Exception): g.addAnyConstant(nts) solver.synthFun("f", {}, boolean, g) with pytest.raises(Exception): g.addAnyConstant(start)