def test_is_selector(solver):
dt_sort = create_datatype_sort(solver)
dt = dt_sort.getDatatype()
dt0 = dt[0]
dt01 = dt0[1]
cons_sort = dt01.getSelectorTerm().getSort()
assert cons_sort.isDatatypeSelector()
Sort(solver).isDatatypeSelector()
def test_operators_comparison(solver):
solver.getIntegerSort() == Sort(solver)
solver.getIntegerSort() != Sort(solver)
solver.getIntegerSort() < Sort(solver)
solver.getIntegerSort() <= Sort(solver)
solver.getIntegerSort() > Sort(solver)
solver.getIntegerSort() >= Sort(solver)
def test_has_get_symbol(solver):
n = Sort(solver)
b = solver.getBooleanSort()
s0 = solver.mkParamSort("s0")
s1 = solver.mkParamSort("|s1\\|")
with pytest.raises(RuntimeError):
n.hasSymbol()
assert not b.hasSymbol()
assert s0.hasSymbol()
assert s1.hasSymbol()
with pytest.raises(RuntimeError):
n.getSymbol()
with pytest.raises(RuntimeError):
b.getSymbol()
assert s0.getSymbol() == "s0"
assert s1.getSymbol() == "|s1\\|"
def test_is_set(solver):
set_sort = solver.mkSetSort(solver.getRealSort())
assert set_sort.isSet()
Sort(solver).isSet()
def test_is_record(solver):
rec_sort = solver.mkRecordSort([("asdf", solver.getRealSort())])
assert rec_sort.isRecord()
Sort(solver).isRecord()
def test_is_array(solver):
arr_sort = solver.mkArraySort(solver.getRealSort(),
solver.getIntegerSort())
assert arr_sort.isArray()
Sort(solver).isArray()
def test_is_sort_constructor(solver):
sc_sort = solver.mkSortConstructorSort("asdf", 1)
assert sc_sort.isSortConstructor()
Sort(solver).isSortConstructor()
def test_is_tuple(solver):
tup_sort = solver.mkTupleSort(solver.getRealSort())
assert tup_sort.isTuple()
Sort(solver).isTuple()
def test_is_reg_exp(solver):
assert solver.getRegExpSort().isRegExp()
Sort(solver).isRegExp()
def test_is_integer(solver):
assert solver.getIntegerSort().isInteger()
assert not solver.getRealSort().isInteger()
Sort(solver).isInteger()
def test_is_uninterpreted(solver):
un_sort = solver.mkUninterpretedSort("asdf")
assert un_sort.isUninterpretedSort()
Sort(solver).isUninterpretedSort()
def test_is_real(solver):
assert solver.getRealSort().isReal()
assert not solver.getIntegerSort().isReal()
Sort(solver).isReal()
def test_is_datatype(solver):
dt_sort = create_datatype_sort(solver)
assert dt_sort.isDatatype()
Sort(solver).isDatatype()
def test_is_constructor(solver):
dt_sort = create_datatype_sort(solver)
dt = dt_sort.getDatatype()
cons_sort = dt[0].getConstructorTerm().getSort()
assert cons_sort.isDatatypeConstructor()
Sort(solver).isDatatypeConstructor()
def test_is_floating_point(solver):
assert solver.mkFloatingPointSort(8, 24).isFloatingPoint()
Sort(solver).isFloatingPoint()
def test_is_bit_vector(solver):
assert solver.mkBitVectorSort(8).isBitVector()
Sort(solver).isBitVector()
def test_is_rounding_mode(solver):
assert solver.getRoundingModeSort().isRoundingMode()
Sort(solver).isRoundingMode()
def test_is_bag(solver):
bag_sort = solver.mkBagSort(solver.getRealSort())
assert bag_sort.isBag()
Sort(solver).isBag()
def test_is_null(solver):
x = Sort(solver)
assert x.isNull()
x = solver.getBooleanSort()
assert not x.isNull()
def test_is_sequence(solver):
seq_sort = solver.mkSequenceSort(solver.getRealSort())
assert seq_sort.isSequence()
Sort(solver).isSequence()
def test_is_string(solver):
assert solver.getStringSort().isString()
Sort(solver).isString()
def test_is_sort_constructor(solver):
sc_sort = solver.mkUninterpretedSortConstructorSort("asdf", 1)
assert sc_sort.isUninterpretedSortConstructor()
Sort(solver).isUninterpretedSortConstructor()
def test_is_tester(solver):
dt_sort = create_datatype_sort(solver)
dt = dt_sort.getDatatype()
cons_sort = dt[0].getTesterTerm().getSort()
assert cons_sort.isDatatypeTester()
Sort(solver).isDatatypeTester()
def test_is_updater(solver):
dt_sort = create_datatype_sort(solver)
dt = dt_sort.getDatatype()
updater_sort = dt[0][0].getUpdaterTerm().getSort()
assert updater_sort.isDatatypeUpdater()
Sort(solver).isDatatypeUpdater()
def test_is_function(solver):
fun_sort = solver.mkFunctionSort(solver.getRealSort(),
solver.getIntegerSort())
assert fun_sort.isFunction()
Sort(solver).isFunction()
def test_is_boolean(solver):
assert solver.getBooleanSort().isBoolean()
Sort(solver).isBoolean()
def test_is_predicate(solver):
pred_sort = solver.mkPredicateSort(solver.getRealSort())
assert pred_sort.isPredicate()
Sort(solver).isPredicate()
def test_datatype_structs(solver):
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
# create datatype sort to test
dtypeSpec = solver.mkDatatypeDecl("list")
cons = solver.mkDatatypeConstructorDecl("cons")
cons.addSelector("head", intSort)
cons.addSelectorSelf("tail")
nullSort = Sort(solver)
with pytest.raises(RuntimeError):
cons.addSelector("null", nullSort)
dtypeSpec.addConstructor(cons)
nil = solver.mkDatatypeConstructorDecl("nil")
dtypeSpec.addConstructor(nil)
dtypeSort = solver.mkDatatypeSort(dtypeSpec)
dt = dtypeSort.getDatatype()
# not parametric datatype
with pytest.raises(RuntimeError): dt.getParameters()
assert not dt.isCodatatype()
assert not dt.isTuple()
assert not dt.isRecord()
assert not dt.isFinite()
assert dt.isWellFounded()
# get constructor
dcons = dt[0]
consTerm = dcons.getTerm()
assert dcons.getNumSelectors() == 2
# create datatype sort to test
dtypeSpecEnum = solver.mkDatatypeDecl("enum")
ca = solver.mkDatatypeConstructorDecl("A")
dtypeSpecEnum.addConstructor(ca)
cb = solver.mkDatatypeConstructorDecl("B")
dtypeSpecEnum.addConstructor(cb)
cc = solver.mkDatatypeConstructorDecl("C")
dtypeSpecEnum.addConstructor(cc)
dtypeSortEnum = solver.mkDatatypeSort(dtypeSpecEnum)
dtEnum = dtypeSortEnum.getDatatype()
assert not dtEnum.isTuple()
assert dtEnum.isFinite()
# create codatatype
dtypeSpecStream = solver.mkDatatypeDecl("stream", True)
consStream = solver.mkDatatypeConstructorDecl("cons")
consStream.addSelector("head", intSort)
consStream.addSelectorSelf("tail")
dtypeSpecStream.addConstructor(consStream)
dtypeSortStream = solver.mkDatatypeSort(dtypeSpecStream)
dtStream = dtypeSortStream.getDatatype()
assert dtStream.isCodatatype()
assert not dtStream.isFinite()
# codatatypes may be well-founded
assert dtStream.isWellFounded()
# create tuple
tupSort = solver.mkTupleSort(boolSort)
dtTuple = tupSort.getDatatype()
assert dtTuple.isTuple()
assert not dtTuple.isRecord()
assert dtTuple.isFinite()
assert dtTuple.isWellFounded()
# create record
fields = [("b", boolSort), ("i", intSort)]
recSort = solver.mkRecordSort(*fields)
assert recSort.isDatatype()
dtRecord = recSort.getDatatype()
assert not dtRecord.isTuple()
assert dtRecord.isRecord()
assert not dtRecord.isFinite()
assert dtRecord.isWellFounded()
def test_is_parametric_datatype(solver):
param_dt_sort = create_param_datatype_sort(solver)
assert param_dt_sort.isParametricDatatype()
Sort(solver).isParametricDatatype()