diff options
30 files changed, 8237 insertions, 442 deletions
diff --git a/.clang-format b/.clang-format index a4e83f330..fc35b4e00 100644 --- a/.clang-format +++ b/.clang-format @@ -20,8 +20,20 @@ DerivePointerAlignment: false --- Language: Java BasedOnStyle: Google -ColumnLimit: 80 +AllowShortCaseLabelsOnASingleLine: true BinPackArguments: false BinPackParameters: false BreakBeforeBinaryOperators: NonAssignment +BraceWrapping: + AfterCaseLabel: true + AfterClass: true + AfterControlStatement: true + AfterEnum: true + AfterFunction: true + AfterStruct: true + AfterUnion: true + BeforeCatch: true + BeforeElse: true +BreakBeforeBraces: Custom +DerivePointerAlignment: false ... diff --git a/src/api/java/CMakeLists.txt b/src/api/java/CMakeLists.txt index d1e818f30..69605c06a 100644 --- a/src/api/java/CMakeLists.txt +++ b/src/api/java/CMakeLists.txt @@ -48,10 +48,25 @@ include(UseJava) # specify java source files set(JAVA_FILES + ${CMAKE_CURRENT_LIST_DIR}/cvc5/AbstractPointer.java ${CMAKE_CURRENT_LIST_DIR}/cvc5/CVC5ApiException.java ${CMAKE_CURRENT_LIST_DIR}/cvc5/CVC5ApiRecoverableException.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Datatype.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/DatatypeConstructor.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/DatatypeConstructorDecl.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/DatatypeDecl.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/DatatypeSelector.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Grammar.java ${CMAKE_CURRENT_LIST_DIR}/cvc5/IPointer.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Op.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Pair.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Result.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/RoundingMode.java ${CMAKE_CURRENT_LIST_DIR}/cvc5/Solver.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Sort.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Stat.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Statistics.java + ${CMAKE_CURRENT_LIST_DIR}/cvc5/Term.java ${CMAKE_CURRENT_LIST_DIR}/cvc5/Utils.java ${JAVA_KIND_FILE} ) @@ -92,8 +107,19 @@ message(STATUS "JAVA_INCLUDE_PATH2 : ${JAVA_INCLUDE_PATH2}") message(STATUS "JAVA_AWT_INCLUDE_PATH: ${JAVA_AWT_INCLUDE_PATH}") add_library(cvc5jni SHARED + jni/cvc5_Datatype.cpp + jni/cvc5_DatatypeConstructor.cpp + jni/cvc5_DatatypeConstructorDecl.cpp + jni/cvc5_DatatypeDecl.cpp + jni/cvc5_DatatypeSelector.cpp + jni/cvc5_Grammar.cpp + jni/cvc5_Op.cpp + jni/cvc5_Result.cpp jni/cvc5_Solver.cpp -) + jni/cvc5_Sort.cpp + jni/cvc5_Stat.cpp + jni/cvc5_Statistics.cpp + jni/cvc5_Term.cpp) add_dependencies(cvc5jni generate-jni-headers) target_include_directories(cvc5jni PUBLIC ${JNI_INCLUDE_DIRS}) diff --git a/src/api/java/cvc5/AbstractPointer.java b/src/api/java/cvc5/AbstractPointer.java new file mode 100644 index 000000000..f6cdff8ad --- /dev/null +++ b/src/api/java/cvc5/AbstractPointer.java @@ -0,0 +1,40 @@ +/****************************************************************************** + * Top contributors (to current version): + * Mudathir Mohamed + * + * This file is part of the cvc5 project. + * + * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS + * in the top-level source directory and their institutional affiliations. + * All rights reserved. See the file COPYING in the top-level source + * directory for licensing information. + * **************************************************************************** + * + * The cvc5 java API. + */ + +package cvc5; + +abstract class AbstractPointer implements IPointer +{ + protected final Solver solver; + protected final long pointer; + + public long getPointer() + { + return pointer; + } + + @Override public String toString() + { + return toString(pointer); + } + + abstract protected String toString(long pointer); + + AbstractPointer(Solver solver, long pointer) + { + this.solver = solver; + this.pointer = pointer; + } +} diff --git a/src/api/java/cvc5/CVC5ApiRecoverableException.java b/src/api/java/cvc5/CVC5ApiRecoverableException.java index 3f434d0ff..035a79ab6 100644 --- a/src/api/java/cvc5/CVC5ApiRecoverableException.java +++ b/src/api/java/cvc5/CVC5ApiRecoverableException.java @@ -13,7 +13,6 @@ * The cvc5 java API. */ - package cvc5; public class CVC5ApiRecoverableException extends CVC5ApiException diff --git a/src/api/java/cvc5/Datatype.java b/src/api/java/cvc5/Datatype.java index be1e47671..42e06286c 100644 --- a/src/api/java/cvc5/Datatype.java +++ b/src/api/java/cvc5/Datatype.java @@ -15,7 +15,10 @@ package cvc5; -public class Datatype extends AbstractPointer +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class Datatype extends AbstractPointer implements Iterable<DatatypeConstructor> { // region construction and destruction Datatype(Solver solver, long pointer) @@ -30,8 +33,7 @@ public class Datatype extends AbstractPointer return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } @@ -195,4 +197,37 @@ public class Datatype extends AbstractPointer * @return a string representation of this datatype */ protected native String toString(long pointer); + + public class ConstIterator implements Iterator<DatatypeConstructor> + { + private int currentIndex; + private int size; + + public ConstIterator() + { + currentIndex = -1; + size = getNumConstructors(); + } + + @Override public boolean hasNext() + { + return currentIndex < size - 1; + } + + @Override public DatatypeConstructor next() + { + if (currentIndex >= size - 1) + { + throw new NoSuchElementException(); + } + currentIndex++; + + return getConstructor(currentIndex); + } + } + + @Override public Iterator<DatatypeConstructor> iterator() + { + return new ConstIterator(); + } } diff --git a/src/api/java/cvc5/DatatypeConstructor.java b/src/api/java/cvc5/DatatypeConstructor.java index eb489456b..7c0ee21d5 100644 --- a/src/api/java/cvc5/DatatypeConstructor.java +++ b/src/api/java/cvc5/DatatypeConstructor.java @@ -15,7 +15,10 @@ package cvc5; -public class DatatypeConstructor extends AbstractPointer +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class DatatypeConstructor extends AbstractPointer implements Iterable<DatatypeSelector> { // region construction and destruction DatatypeConstructor(Solver solver, long pointer) @@ -30,8 +33,7 @@ public class DatatypeConstructor extends AbstractPointer return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } @@ -39,7 +41,7 @@ public class DatatypeConstructor extends AbstractPointer // endregion /** @return the name of this Datatype constructor. */ - String getName() + public String getName() { return getName(pointer); } @@ -50,7 +52,7 @@ public class DatatypeConstructor extends AbstractPointer * Get the constructor operator of this datatype constructor. * @return the constructor term */ - Term getConstructorTerm() + public Term getConstructorTerm() { long termPointer = getConstructorTerm(pointer); return new Term(solver, termPointer); @@ -81,7 +83,7 @@ public class DatatypeConstructor extends AbstractPointer * @param retSort the desired return sort of the constructor * @return the constructor term */ - Term getSpecializedConstructorTerm(Sort retSort) + public Term getSpecializedConstructorTerm(Sort retSort) { long termPointer = getSpecializedConstructorTerm(pointer, retSort.getPointer()); return new Term(solver, termPointer); @@ -93,7 +95,7 @@ public class DatatypeConstructor extends AbstractPointer * Get the tester operator of this datatype constructor. * @return the tester operator */ - Term getTesterTerm() + public Term getTesterTerm() { long termPointer = getTesterTerm(pointer); return new Term(solver, termPointer); @@ -103,7 +105,7 @@ public class DatatypeConstructor extends AbstractPointer /** * @return the number of selectors (so far) of this Datatype constructor. */ - int getNumSelectors() + public int getNumSelectors() { return getNumSelectors(pointer); } @@ -138,7 +140,7 @@ public class DatatypeConstructor extends AbstractPointer * @param name the name of the datatype selector * @return a term representing the datatype selector with the given name */ - Term getSelectorTerm(String name) + public Term getSelectorTerm(String name) { long termPointer = getSelectorTerm(pointer, name); return new Term(solver, termPointer); @@ -148,7 +150,7 @@ public class DatatypeConstructor extends AbstractPointer /** * @return true if this DatatypeConstructor is a null object */ - boolean isNull() + public boolean isNull() { return isNull(pointer); } @@ -159,4 +161,37 @@ public class DatatypeConstructor extends AbstractPointer * @return a string representation of this datatype constructor */ protected native String toString(long pointer); + + public class ConstIterator implements Iterator<DatatypeSelector> + { + private int currentIndex; + private int size; + + public ConstIterator() + { + currentIndex = -1; + size = getNumSelectors(); + } + + @Override public boolean hasNext() + { + return currentIndex < size - 1; + } + + @Override public DatatypeSelector next() + { + if (currentIndex >= size - 1) + { + throw new NoSuchElementException(); + } + currentIndex++; + + return getSelector(currentIndex); + } + } + + @Override public Iterator<DatatypeSelector> iterator() + { + return new ConstIterator(); + } } diff --git a/src/api/java/cvc5/DatatypeConstructorDecl.java b/src/api/java/cvc5/DatatypeConstructorDecl.java index 8c1cfed7d..9769aa2fb 100644 --- a/src/api/java/cvc5/DatatypeConstructorDecl.java +++ b/src/api/java/cvc5/DatatypeConstructorDecl.java @@ -30,8 +30,7 @@ public class DatatypeConstructorDecl extends AbstractPointer return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } diff --git a/src/api/java/cvc5/DatatypeDecl.java b/src/api/java/cvc5/DatatypeDecl.java index 4be50f92f..fa78c68ac 100644 --- a/src/api/java/cvc5/DatatypeDecl.java +++ b/src/api/java/cvc5/DatatypeDecl.java @@ -30,8 +30,7 @@ public class DatatypeDecl extends AbstractPointer return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } diff --git a/src/api/java/cvc5/DatatypeSelector.java b/src/api/java/cvc5/DatatypeSelector.java index b4e9fd6b6..77136173e 100644 --- a/src/api/java/cvc5/DatatypeSelector.java +++ b/src/api/java/cvc5/DatatypeSelector.java @@ -30,8 +30,7 @@ public class DatatypeSelector extends AbstractPointer return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } diff --git a/src/api/java/cvc5/Grammar.java b/src/api/java/cvc5/Grammar.java index f8c6b05c5..72558d15b 100644 --- a/src/api/java/cvc5/Grammar.java +++ b/src/api/java/cvc5/Grammar.java @@ -15,20 +15,23 @@ package cvc5; -public class Grammar extends AbstractPointer { +public class Grammar extends AbstractPointer +{ // region construction and destruction - Grammar(Solver solver, long pointer) { + Grammar(Solver solver, long pointer) + { super(solver, pointer); } protected static native void deletePointer(long pointer); - public long getPointer() { + public long getPointer() + { return pointer; } - @Override - public void finalize() { + @Override public void finalize() + { deletePointer(pointer); } @@ -39,31 +42,32 @@ public class Grammar extends AbstractPointer { * @param ntSymbol the non-terminal to which the rule is added * @param rule the rule to add */ - public void addRule(Term ntSymbol, Term rule) { + public void addRule(Term ntSymbol, Term rule) + { addRule(pointer, ntSymbol.getPointer(), rule.getPointer()); } - private native void addRule( - long pointer, long ntSymbolPointer, long rulePointer); + private native void addRule(long pointer, long ntSymbolPointer, long rulePointer); /** * Add \p rules to the set of rules corresponding to \p ntSymbol. * @param ntSymbol the non-terminal to which the rules are added * @param rules the rules to add */ - public void addRules(Term ntSymbol, Term[] rules) { + public void addRules(Term ntSymbol, Term[] rules) + { long[] pointers = Utils.getPointers(rules); addRules(pointer, ntSymbol.getPointer(), pointers); } - public native void addRules( - long pointer, long ntSymbolPointer, long[] rulePointers); + public native void addRules(long pointer, long ntSymbolPointer, long[] rulePointers); /** * Allow \p ntSymbol to be an arbitrary constant. * @param ntSymbol the non-terminal allowed to be any constant */ - void addAnyConstant(Term ntSymbol) { + public void addAnyConstant(Term ntSymbol) + { addAnyConstant(pointer, ntSymbol.getPointer()); } @@ -74,7 +78,8 @@ public class Grammar extends AbstractPointer { * synth-fun/synth-inv with the same sort as \p ntSymbol. * @param ntSymbol the non-terminal allowed to be any input constant */ - void addAnyVariable(Term ntSymbol) { + public void addAnyVariable(Term ntSymbol) + { addAnyVariable(pointer, ntSymbol.getPointer()); } diff --git a/src/api/java/cvc5/IPointer.java b/src/api/java/cvc5/IPointer.java index fc9c95338..17d6d5974 100644 --- a/src/api/java/cvc5/IPointer.java +++ b/src/api/java/cvc5/IPointer.java @@ -15,7 +15,6 @@ package cvc5; -interface IPointer -{ +interface IPointer { long getPointer(); } diff --git a/src/api/java/cvc5/Op.java b/src/api/java/cvc5/Op.java index 98915c1d1..6819946b6 100644 --- a/src/api/java/cvc5/Op.java +++ b/src/api/java/cvc5/Op.java @@ -15,20 +15,23 @@ package cvc5; -public class Op extends AbstractPointer { +public class Op extends AbstractPointer +{ // region construction and destruction - Op(Solver solver, long pointer) { + Op(Solver solver, long pointer) + { super(solver, pointer); } protected static native void deletePointer(long pointer); - public long getPointer() { + public long getPointer() + { return pointer; } - @Override - public void finalize() { + @Override public void finalize() + { deletePointer(pointer); } @@ -41,8 +44,8 @@ public class Op extends AbstractPointer { * @param t the operator to compare to for equality * @return true if the operators are equal */ - @Override - public boolean equals(Object t) { + @Override public boolean equals(Object t) + { if (this == t) return true; if (t == null || getClass() != t.getClass()) @@ -55,11 +58,15 @@ public class Op extends AbstractPointer { /** * @return the kind of this operator */ - Kind getKind() { - try { + Kind getKind() + { + try + { int value = getKind(pointer); return Kind.fromInt(value); - } catch (CVC5ApiException e) { + } + catch (CVC5ApiException e) + { e.printStackTrace(); throw new RuntimeException(e.getMessage()); } @@ -70,7 +77,8 @@ public class Op extends AbstractPointer { /** * @return true if this operator is a null term */ - public boolean isNull() { + public boolean isNull() + { return isNull(pointer); } @@ -79,7 +87,8 @@ public class Op extends AbstractPointer { /** * @return true iff this operator is indexed */ - public boolean isIndexed() { + public boolean isIndexed() + { return isIndexed(pointer); } @@ -88,7 +97,8 @@ public class Op extends AbstractPointer { /** * @return the number of indices of this op */ - public int getNumIndices() { + public int getNumIndices() + { return getNumIndices(pointer); } @@ -100,7 +110,8 @@ public class Op extends AbstractPointer { * * @return the indices used to create this Op */ - public int[] getIntegerIndices() { + public int[] getIntegerIndices() + { return getIntegerIndices(pointer); } @@ -112,7 +123,8 @@ public class Op extends AbstractPointer { * * @return the indices used to create this Op */ - public String[] getStringIndices() { + public String[] getStringIndices() + { return getStringIndices(pointer); } diff --git a/src/api/java/cvc5/Pair.java b/src/api/java/cvc5/Pair.java new file mode 100644 index 000000000..19cd3e797 --- /dev/null +++ b/src/api/java/cvc5/Pair.java @@ -0,0 +1,41 @@ +/****************************************************************************** + * Top contributors (to current version): + * Mudathir Mohamed + * + * This file is part of the cvc5 project. + * + * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS + * in the top-level source directory and their institutional affiliations. + * All rights reserved. See the file COPYING in the top-level source + * directory for licensing information. + * **************************************************************************** + * + * The cvc5 java API. + */ + +package cvc5; + +public class Pair<K, V> +{ + public K first; + public V second; + public Pair(K first, V second) + { + this.first = first; + this.second = second; + } + + @Override public boolean equals(Object pair) + { + if (this == pair) + return true; + if (pair == null || getClass() != pair.getClass()) + return false; + + Pair<K, V> p = (Pair<K, V>) pair; + + if (!first.equals(p.first)) + return false; + return second.equals(p.second); + } +} diff --git a/src/api/java/cvc5/Result.java b/src/api/java/cvc5/Result.java index 4399df1e4..3573094a3 100644 --- a/src/api/java/cvc5/Result.java +++ b/src/api/java/cvc5/Result.java @@ -33,16 +33,14 @@ public class Result extends AbstractPointer return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } // endregion - public enum UnknownExplanation - { + public enum UnknownExplanation { REQUIRES_FULL_CHECK(0), INCOMPLETE(1), TIMEOUT(2), diff --git a/src/api/java/cvc5/RoundingMode.java b/src/api/java/cvc5/RoundingMode.java new file mode 100644 index 000000000..4229bb74a --- /dev/null +++ b/src/api/java/cvc5/RoundingMode.java @@ -0,0 +1,63 @@ +/****************************************************************************** + * Top contributors (to current version): + * Aina Niemetz, Andrew Reynolds, Abdalrhman Mohamed, Mudathir Mohamed + * + * This file is part of the cvc5 project. + * + * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS + * in the top-level source directory and their institutional affiliations. + * All rights reserved. See the file COPYING in the top-level source + * directory for licensing information. + * **************************************************************************** + * + * The cvc5 java API. + */ + +package cvc5; + +public enum RoundingMode { + /** + * Round to the nearest even number. + * If the two nearest floating-point numbers bracketing an unrepresentable + * infinitely precise result are equally near, the one with an even least + * significant digit will be delivered. + */ + ROUND_NEAREST_TIES_TO_EVEN(0), + /** + * Round towards positive infinity (+oo). + * The result shall be the format’s floating-point number (possibly +oo) + * closest to and no less than the infinitely precise result. + */ + ROUND_TOWARD_POSITIVE(1), + /** + * Round towards negative infinity (-oo). + * The result shall be the format’s floating-point number (possibly -oo) + * closest to and no less than the infinitely precise result. + */ + ROUND_TOWARD_NEGATIVE(2), + /** + * Round towards zero. + * The result shall be the format’s floating-point number closest to and no + * greater in magnitude than the infinitely precise result. + */ + ROUND_TOWARD_ZERO(3), + /** + * Round to the nearest number away from zero. + * If the two nearest floating-point numbers bracketing an unrepresentable + * infinitely precise result are equally near, the one with larger magnitude + * will be selected. + */ + ROUND_NEAREST_TIES_TO_AWAY(4); + + private int value; + + private RoundingMode(int value) + { + this.value = value; + } + + public int getValue() + { + return value; + } +} diff --git a/src/api/java/cvc5/Solver.java b/src/api/java/cvc5/Solver.java index 6bb1b6b1e..65efcb170 100644 --- a/src/api/java/cvc5/Solver.java +++ b/src/api/java/cvc5/Solver.java @@ -16,6 +16,7 @@ package cvc5; import java.io.IOException; +import java.util.*; public class Solver implements IPointer { @@ -26,11 +27,6 @@ public class Solver implements IPointer return pointer; } - public Solver() - { - this.pointer = newSolver(); - } - private native long newSolver(); public void deletePointer() @@ -38,24 +34,2487 @@ public class Solver implements IPointer deletePointer(pointer); } - private static native void deletePointer(long solverPointer); + private static native void deletePointer(long pointer); + + @Override public void finalize() + { + deletePointer(pointer); + } static { Utils.loadLibraries(); } + /* .................................................................... */ + /* Constructors */ + /* .................................................................... */ + + public Solver() + { + this.pointer = newSolver(); + } + + /* .................................................................... */ + /* Sorts Handling */ + /* .................................................................... */ + /** - * Set logic. - * SMT-LIB: ( set-logic <symbol> ) + * @return sort null + */ + + public Sort getNullSort() + { + long sortPointer = getNullSort(pointer); + return new Sort(this, sortPointer); + } + + private native long getNullSort(long pointer); + + /** + * @return sort Boolean + */ + public Sort getBooleanSort() + { + long sortPointer = getBooleanSort(pointer); + return new Sort(this, sortPointer); + } + + private native long getBooleanSort(long pointer); + + /** + * @return sort Integer (in cvc5, Integer is a subtype of Real) + */ + public Sort getIntegerSort() + { + long sortPointer = getIntegerSort(pointer); + return new Sort(this, sortPointer); + } + + public native long getIntegerSort(long pointer); + /** + * @return sort Real + */ + public Sort getRealSort() + { + long sortPointer = getRealSort(pointer); + return new Sort(this, sortPointer); + } + + private native long getRealSort(long pointer); + /** + * @return sort RegExp + */ + public Sort getRegExpSort() + { + long sortPointer = getRegExpSort(pointer); + return new Sort(this, sortPointer); + } + + private native long getRegExpSort(long pointer); + /** + * @return sort RoundingMode + */ + public Sort getRoundingModeSort() throws CVC5ApiException + { + long sortPointer = getRoundingModeSort(pointer); + return new Sort(this, sortPointer); + } + + private native long getRoundingModeSort(long pointer) throws CVC5ApiException; + /** + * @return sort String + */ + public Sort getStringSort() + { + long sortPointer = getStringSort(pointer); + return new Sort(this, sortPointer); + } + + private native long getStringSort(long solverPointer); + /** + * Create an array sort. + * @param indexSort the array index sort + * @param elemSort the array element sort + * @return the array sort + */ + public Sort mkArraySort(Sort indexSort, Sort elemSort) + { + long sortPointer = mkArraySort(pointer, indexSort.getPointer(), elemSort.getPointer()); + return new Sort(this, sortPointer); + } + + private native long mkArraySort(long pointer, long indexSortPointer, long elementSortPointer); + + /** + * Create a bit-vector sort. + * @param size the bit-width of the bit-vector sort + * @return the bit-vector sort + */ + public Sort mkBitVectorSort(int size) throws CVC5ApiException + { + Utils.validateUnsigned(size, "size"); + long sortPointer = mkBitVectorSort(pointer, size); + return new Sort(this, sortPointer); + } + + private native long mkBitVectorSort(long pointer, int size); + + /** + * Create a floating-point sort. + * @param exp the bit-width of the exponent of the floating-point sort. + * @param sig the bit-width of the significand of the floating-point sort. + */ + public Sort mkFloatingPointSort(int exp, int sig) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long sortPointer = mkFloatingPointSort(pointer, exp, sig); + return new Sort(this, sortPointer); + } + + private native long mkFloatingPointSort(long solverPointer, int exp, int sig); + + /** + * Create a datatype sort. + * @param dtypedecl the datatype declaration from which the sort is + * created + * @return the datatype sort + */ + public Sort mkDatatypeSort(DatatypeDecl dtypedecl) throws CVC5ApiException + { + long pointer = mkDatatypeSort(this.pointer, dtypedecl.getPointer()); + return new Sort(this, pointer); + } + + private native long mkDatatypeSort(long pointer, long datatypeDeclPointer) + throws CVC5ApiException; + + /** + * Create a vector of datatype sorts. The names of the datatype + * declarations must be distinct. + * + * @param dtypedecls the datatype declarations from which the sort is + * created + * @return the datatype sorts + */ + public Sort[] mkDatatypeSorts(List<DatatypeDecl> dtypedecls) throws CVC5ApiException + { + return mkDatatypeSorts(dtypedecls.toArray(new DatatypeDecl[0])); + } + + /** + * Create a vector of datatype sorts. The names of the datatype + * declarations must be distinct. + * + * @param dtypedecls the datatype declarations from which the sort is + * created + * @return the datatype sorts + */ + public Sort[] mkDatatypeSorts(DatatypeDecl[] dtypedecls) throws CVC5ApiException + { + long[] declPointers = Utils.getPointers(dtypedecls); + long[] sortPointers = mkDatatypeSorts(pointer, declPointers); + Sort[] sorts = Utils.getSorts(this, sortPointers); + return sorts; + } + + private native long[] mkDatatypeSorts(long pointer, long[] declPointers) throws CVC5ApiException; + + /** + * Create a vector of datatype sorts using unresolved sorts. The names of + * the datatype declarations in dtypedecls must be distinct. + * + * This method is called when the DatatypeDecl objects dtypedecls have + * been built using "unresolved" sorts. + * + * We associate each sort in unresolvedSorts with exacly one datatype from + * dtypedecls. In particular, it must have the same name as exactly one + * datatype declaration in dtypedecls. + * + * When constructing datatypes, unresolved sorts are replaced by the + * datatype sort constructed for the datatype declaration it is associated + * with. + * + * @param dtypedecls the datatype declarations from which the sort is + * created + * @param unresolvedSorts the set of unresolved sorts + * @return the datatype sorts + */ + public List<Sort> mkDatatypeSorts(List<DatatypeDecl> dtypedecls, Set<Sort> unresolvedSorts) + throws CVC5ApiException + { + Sort[] array = mkDatatypeSorts( + dtypedecls.toArray(new DatatypeDecl[0]), unresolvedSorts.toArray(new Sort[0])); + return Arrays.asList(array); + } + + /** + * Create a vector of datatype sorts using unresolved sorts. The names of + * the datatype declarations in dtypedecls must be distinct. + * + * This method is called when the DatatypeDecl objects dtypedecls have + * been built using "unresolved" sorts. + * + * We associate each sort in unresolvedSorts with exacly one datatype from + * dtypedecls. In particular, it must have the same name as exactly one + * datatype declaration in dtypedecls. + * + * When constructing datatypes, unresolved sorts are replaced by the + * datatype sort constructed for the datatype declaration it is associated + * with. + * + * @param dtypedecls the datatype declarations from which the sort is + * created + * @param unresolvedSorts the list of unresolved sorts + * @return the datatype sorts + */ + public Sort[] mkDatatypeSorts(DatatypeDecl[] dtypedecls, Sort[] unresolvedSorts) + throws CVC5ApiException + { + long[] declPointers = Utils.getPointers(dtypedecls); + long[] unresolvedPointers = Utils.getPointers(unresolvedSorts); + long[] sortPointers = mkDatatypeSorts(pointer, declPointers, unresolvedPointers); + Sort[] sorts = Utils.getSorts(this, sortPointers); + return sorts; + } + + private native long[] mkDatatypeSorts( + long pointer, long[] declPointers, long[] unresolvedPointers) throws CVC5ApiException; + + /** + * Create function sort. + * @param domain the sort of the fuction argument + * @param codomain the sort of the function return value + * @return the function sort + */ + public Sort mkFunctionSort(Sort domain, Sort codomain) + { + long sortPointer = mkFunctionSort(pointer, domain.getPointer(), codomain.getPointer()); + return new Sort(this, sortPointer); + } + + private native long mkFunctionSort(long pointer, long domainPointer, long codomainPointer); + + /** + * Create function sort. + * @param sorts the sort of the function arguments + * @param codomain the sort of the function return value + * @return the function sort + */ + public Sort mkFunctionSort(Sort[] sorts, Sort codomain) + { + long sortPointer = mkFunctionSort(pointer, Utils.getPointers(sorts), codomain.getPointer()); + return new Sort(this, sortPointer); + } + + private native long mkFunctionSort(long pointer, long[] sortPointers, long codomainPointer); + + /** + * Create a sort parameter. + * @param symbol the name of the sort + * @return the sort parameter + */ + public Sort mkParamSort(String symbol) + { + long sortPointer = mkParamSort(pointer, symbol); + return new Sort(this, sortPointer); + } + + private native long mkParamSort(long pointer, String symbol); + + /** + * Create a predicate sort. + * @param sorts the list of sorts of the predicate + * @return the predicate sort + */ + public Sort mkPredicateSort(Sort[] sorts) + { + long sortPointer = mkPredicateSort(pointer, Utils.getPointers(sorts)); + return new Sort(this, sortPointer); + } + + private native long mkPredicateSort(long pointer, long[] sortPointers); + + /** + * Create a record sort + * @param fields the list of fields of the record + * @return the record sort + */ + public Sort mkRecordSort(Pair<String, Sort>[] fields) + { + long sortPointer = mkRecordSort(pointer, Utils.getPairs(fields)); + return new Sort(this, sortPointer); + } + + private native long mkRecordSort(long pointer, Pair<String, Long>[] fields); + + /** + * Create a set sort. + * @param elemSort the sort of the set elements + * @return the set sort + */ + public Sort mkSetSort(Sort elemSort) + { + long sortPointer = mkSetSort(pointer, elemSort.getPointer()); + return new Sort(this, sortPointer); + } + + private native long mkSetSort(long pointer, long elemSortPointer); + /** + * Create a bag sort. + * @param elemSort the sort of the bag elements + * @return the bag sort + */ + public Sort mkBagSort(Sort elemSort) + { + long sortPointer = mkBagSort(pointer, elemSort.getPointer()); + return new Sort(this, sortPointer); + } + + private native long mkBagSort(long pointer, long elemSortPointer); + + /** + * Create a sequence sort. + * @param elemSort the sort of the sequence elements + * @return the sequence sort + */ + public Sort mkSequenceSort(Sort elemSort) + { + long sortPointer = mkSequenceSort(pointer, elemSort.getPointer()); + return new Sort(this, sortPointer); + } + + private native long mkSequenceSort(long pointer, long elemSortPointer); + + /** + * Create an uninterpreted sort. + * @param symbol the name of the sort + * @return the uninterpreted sort + */ + public Sort mkUninterpretedSort(String symbol) + { + long sortPointer = mkUninterpretedSort(pointer, symbol); + return new Sort(this, sortPointer); + } + + private native long mkUninterpretedSort(long pointer, String symbol); + + /** + * Create a sort constructor sort. + * @param symbol the symbol of the sort + * @param arity the arity of the sort + * @return the sort constructor sort + */ + public Sort mkSortConstructorSort(String symbol, int arity) throws CVC5ApiException + { + Utils.validateUnsigned(arity, "arity"); + long sortPointer = mkSortConstructorSort(pointer, symbol, arity); + return new Sort(this, sortPointer); + } + + private native long mkSortConstructorSort(long pointer, String symbol, int arity); + + /** + * Create a tuple sort. + * @param sorts of the elements of the tuple + * @return the tuple sort + */ + public Sort mkTupleSort(Sort[] sorts) + { + long[] sortPointers = Utils.getPointers(sorts); + long sortPointer = mkTupleSort(pointer, sortPointers); + return new Sort(this, sortPointer); + } + + private native long mkTupleSort(long pointer, long[] sortPointers); + + /* .................................................................... */ + /* Create Terms */ + /* .................................................................... */ + + /** + * Create 0-ary term of given kind. + * @param kind the kind of the term + * @return the Term + */ + public Term mkTerm(Kind kind) + { + long termPointer = mkTerm(pointer, kind.getValue()); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, int kindValue); + + /** + * Create a unary term of given kind. + * @param kind the kind of the term + * @param child the child of the term + * @return the Term + */ + public Term mkTerm(Kind kind, Term child) + { + long termPointer = mkTerm(pointer, kind.getValue(), child.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, int kindValue, long childPointer); + + /** + * Create binary term of given kind. + * @param kind the kind of the term + * @param child1 the first child of the term + * @param child2 the second child of the term + * @return the Term + */ + public Term mkTerm(Kind kind, Term child1, Term child2) + { + long termPointer = mkTerm(pointer, kind.getValue(), child1.getPointer(), child2.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, int kindValue, long child1Pointer, long child2Pointer); + + /** + * Create ternary term of given kind. + * @param kind the kind of the term + * @param child1 the first child of the term + * @param child2 the second child of the term + * @param child3 the third child of the term + * @return the Term + */ + public Term mkTerm(Kind kind, Term child1, Term child2, Term child3) + { + long termPointer = mkTerm( + pointer, kind.getValue(), child1.getPointer(), child2.getPointer(), child3.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm( + long pointer, int kindValue, long child1Pointer, long child2Pointer, long child3Pointer); + /** + * Create n-ary term of given kind. + * @param kind the kind of the term + * @param children the children of the term + * @return the Term + */ + public Term mkTerm(Kind kind, Term[] children) + { + long[] childPointers = Utils.getPointers(children); + long termPointer = mkTerm(pointer, kind.getValue(), childPointers); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, int kindValue, long[] childrenPointers); + + /** + * Create nullary term of given kind from a given operator. + * Create operators with mkOp(). + * @param op the operator + * @return the Term + */ + public Term mkTerm(Op op) + { + long termPointer = mkTerm(pointer, op.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, long opPointer); + /** + * Create unary term of given kind from a given operator. + * Create operators with mkOp(). + * @param op the operator + * @param child the child of the term + * @return the Term + */ + public Term mkTerm(Op op, Term child) + { + long termPointer = mkTerm(pointer, op.getPointer(), child.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, long opPointer, long childPointer); + + /** + * Create binary term of given kind from a given operator. + * Create operators with mkOp(). + * @param op the operator + * @param child1 the first child of the term + * @param child2 the second child of the term + * @return the Term + */ + public Term mkTerm(Op op, Term child1, Term child2) + { + long termPointer = mkTerm(pointer, op.getPointer(), child1.getPointer(), child2.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, long opPointer, long child1Pointer, long child2Pointer); + /** + * Create ternary term of given kind from a given operator. + * Create operators with mkOp(). + * @param op the operator + * @param child1 the first child of the term + * @param child2 the second child of the term + * @param child3 the third child of the term + * @return the Term + */ + public Term mkTerm(Op op, Term child1, Term child2, Term child3) + { + long termPointer = + mkTerm(op.getPointer(), child1.getPointer(), child2.getPointer(), child3.getPointer()); + return new Term(this, termPointer); + } + + private native long mkTerm( + long pointer, long opPointer, long child1Pointer, long child2Pointer, long child3Pointer); + + /** + * Create n-ary term of given kind from a given operator. + * Create operators with mkOp(). + * @param op the operator + * @param children the children of the term + * @return the Term + */ + public Term mkTerm(Op op, List<Term> children) + { + return mkTerm(op, children.toArray(new Term[0])); + } + + /** + * Create n-ary term of given kind from a given operator. + * Create operators with mkOp(). + * @param op the operator + * @param children the children of the term + * @return the Term + */ + public Term mkTerm(Op op, Term[] children) + { + long[] childPointers = Utils.getPointers(children); + long termPointer = mkTerm(pointer, op.getPointer(), childPointers); + return new Term(this, termPointer); + } + + private native long mkTerm(long pointer, long opPointer, long[] childrenPointers); + + /** + * Create a tuple term. Terms are automatically converted if sorts are + * compatible. + * @param sorts The sorts of the elements in the tuple + * @param terms The elements in the tuple + * @return the tuple Term + */ + public Term mkTuple(Sort[] sorts, Term[] terms) + { + long[] sortPointers = Utils.getPointers(sorts); + long[] termPointers = Utils.getPointers(terms); + long termPointer = mkTuple(pointer, sortPointers, termPointers); + return new Term(this, termPointer); + } + + private native long mkTuple(long pointer, long[] sortPointers, long[] termPointers); + + /* .................................................................... */ + /* Create Operators */ + /* .................................................................... */ + + /** + * Create an operator for a builtin Kind + * The Kind may not be the Kind for an indexed operator + * (e.g. BITVECTOR_EXTRACT) + * Note: in this case, the Op simply wraps the Kind. + * The Kind can be used in mkTerm directly without + * creating an op first. + * @param kind the kind to wrap + */ + public Op mkOp(Kind kind) + { + long opPointer = mkOp(pointer, kind.getValue()); + return new Op(this, opPointer); + } + + private native long mkOp(long pointer, int kindValue); + /** + * Create operator of kind: + * - RECORD_UPDATE + * - DIVISIBLE (to support arbitrary precision integers) + * See enum Kind for a description of the parameters. + * @param kind the kind of the operator + * @param arg the string argument to this operator + */ + public Op mkOp(Kind kind, String arg) + { + long opPointer = mkOp(pointer, kind.getValue(), arg); + return new Op(this, opPointer); + } + + private native long mkOp(long pointer, int kindValue, String arg); + + /** + * Create operator of kind: + * - DIVISIBLE + * - BITVECTOR_REPEAT + * - BITVECTOR_ZERO_EXTEND + * - BITVECTOR_SIGN_EXTEND + * - BITVECTOR_ROTATE_LEFT + * - BITVECTOR_ROTATE_RIGHT + * - INT_TO_BITVECTOR + * - FLOATINGPOINT_TO_UBV + * - FLOATINGPOINT_TO_UBV_TOTAL + * - FLOATINGPOINT_TO_SBV + * - FLOATINGPOINT_TO_SBV_TOTAL + * - TUPLE_UPDATE + * See enum Kind for a description of the parameters. + * @param kind the kind of the operator + * @param arg the unsigned int argument to this operator + */ + public Op mkOp(Kind kind, int arg) throws CVC5ApiException + { + Utils.validateUnsigned(arg, "arg"); + long opPointer = mkOp(pointer, kind.getValue(), arg); + return new Op(this, opPointer); + } + + private native long mkOp(long pointer, int kindValue, int arg); + + /** + * Create operator of Kind: + * - BITVECTOR_EXTRACT + * - FLOATINGPOINT_TO_FP_IEEE_BITVECTOR + * - FLOATINGPOINT_TO_FP_FLOATINGPOINT + * - FLOATINGPOINT_TO_FP_REAL + * - FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR + * - FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR + * - FLOATINGPOINT_TO_FP_GENERIC + * See enum Kind for a description of the parameters. + * @param kind the kind of the operator + * @param arg1 the first unsigned int argument to this operator + * @param arg2 the second unsigned int argument to this operator + */ + public Op mkOp(Kind kind, int arg1, int arg2) throws CVC5ApiException + { + Utils.validateUnsigned(arg1, "arg1"); + Utils.validateUnsigned(arg2, "arg2"); + long opPointer = mkOp(pointer, kind.getValue(), arg1, arg2); + return new Op(this, opPointer); + } + + private native long mkOp(long pointer, int kindValue, int arg1, int arg2); + + /** + * Create operator of Kind: + * - TUPLE_PROJECT + * See enum Kind for a description of the parameters. + * @param kind the kind of the operator + * @param args the arguments (indices) of the operator + */ + public Op mkOp(Kind kind, int[] args) throws CVC5ApiException + { + Utils.validateUnsigned(args, "args"); + long opPointer = mkOp(pointer, kind.getValue(), args); + return new Op(this, opPointer); + } + + private native long mkOp(long pointer, int kindValue, int[] args); + + /* .................................................................... */ + /* Create Constants */ + /* .................................................................... */ + + /** + * Create a Boolean true constant. + * @return the true constant + */ + public Term mkTrue() + { + long termPointer = mkTrue(pointer); + return new Term(this, termPointer); + } + + private native long mkTrue(long pointer); + /** + * Create a Boolean false constant. + * @return the false constant + */ + public Term mkFalse() + { + long termPointer = mkFalse(pointer); + return new Term(this, termPointer); + } + + private native long mkFalse(long pointer); + /** + * Create a Boolean constant. + * @return the Boolean constant + * @param val the value of the constant + */ + public Term mkBoolean(boolean val) + { + long termPointer = mkBoolean(pointer, val); + return new Term(this, termPointer); + } + + private native long mkBoolean(long pointer, boolean val); + /** + * Create a constant representing the number Pi. + * @return a constant representing Pi + */ + public Term mkPi() + { + long termPointer = mkPi(pointer); + return new Term(this, termPointer); + } + + private native long mkPi(long pointer); + /** + * Create an integer constant from a string. + * @param s the string representation of the constant, may represent an + * integer (e.g., "123"). + * @return a constant of sort Integer assuming 's' represents an integer) + */ + public Term mkInteger(String s) throws CVC5ApiException + { + long termPointer = mkInteger(pointer, s); + return new Term(this, termPointer); + } + + private native long mkInteger(long pointer, String s) throws CVC5ApiException; + + /** + * Create an integer constant from a c++ int. + * @param val the value of the constant + * @return a constant of sort Integer + */ + public Term mkInteger(long val) + { + long termPointer = mkInteger(pointer, val); + return new Term(this, termPointer); + } + + private native long mkInteger(long pointer, long val); + /** + * Create a real constant from a string. + * @param s the string representation of the constant, may represent an + * integer (e.g., "123") or real constant (e.g., "12.34" or + * "12/34"). + * @return a constant of sort Real + */ + public Term mkReal(String s) throws CVC5ApiException + { + long termPointer = mkReal(pointer, s); + return new Term(this, termPointer); + } + + private native long mkReal(long pointer, String s) throws CVC5ApiException; + /** + * Create a real constant from an integer. + * @param val the value of the constant + * @return a constant of sort Integer + */ + public Term mkReal(long val) + { + long termPointer = mkRealValue(pointer, val); + return new Term(this, termPointer); + } + + private native long mkRealValue(long pointer, long val); + /** + * Create a real constant from a rational. + * @param num the value of the numerator + * @param den the value of the denominator + * @return a constant of sort Real + */ + public Term mkReal(long num, long den) + { + long termPointer = mkReal(pointer, num, den); + return new Term(this, termPointer); + } + + private native long mkReal(long pointer, long num, long den); + + /** + * Create a regular expression empty term. + * @return the empty term + */ + public Term mkRegexpEmpty() + { + long termPointer = mkRegexpEmpty(pointer); + return new Term(this, termPointer); + } + + private native long mkRegexpEmpty(long pointer); + + /** + * Create a regular expression sigma term. + * @return the sigma term + */ + public Term mkRegexpSigma() + { + long termPointer = mkRegexpSigma(pointer); + return new Term(this, termPointer); + } + + private native long mkRegexpSigma(long pointer); + + /** + * Create a constant representing an empty set of the given sort. + * @param sort the sort of the set elements. + * @return the empty set constant + */ + public Term mkEmptySet(Sort sort) + { + long termPointer = mkEmptySet(pointer, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long mkEmptySet(long pointer, long sortPointer); + /** + * Create a constant representing an empty bag of the given sort. + * @param sort the sort of the bag elements. + * @return the empty bag constant + */ + public Term mkEmptyBag(Sort sort) + { + long termPointer = mkEmptyBag(pointer, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long mkEmptyBag(long pointer, long sortPointer); + + /** + * Create a separation logic nil term. + * @param sort the sort of the nil term + * @return the separation logic nil term + */ + public Term mkSepNil(Sort sort) + { + long termPointer = mkSepNil(pointer, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long mkSepNil(long pointer, long sortPointer); + + /** + * Create a String constant. + * @param s the string this constant represents + * @return the String constant + */ + public Term mkString(String s) + { + return mkString(s, false); + } + + /** + * Create a String constant. + * @param s the string this constant represents + * @param useEscSequences determines whether escape sequences in `s` + * should be converted to the corresponding unicode character + * @return the String constant + */ + public Term mkString(String s, boolean useEscSequences) + { + // TODO: review unicode + long termPointer = mkString(pointer, s, useEscSequences); + return new Term(this, termPointer); + } + + private native long mkString(long pointer, String s, boolean useEscSequences); + + /** + * Create a String constant. + * @param s a list of unsigned (unicode) values this constant represents + * as + * string + * @return the String constant + */ + public Term mkString(int[] s) throws CVC5ApiException + { + Utils.validateUnsigned(s, "s"); + long termPointer = mkString(pointer, s); + return new Term(this, termPointer); + } + + private native long mkString(long pointer, int[] s); + + /** + * Create an empty sequence of the given element sort. + * @param sort The element sort of the sequence. + * @return the empty sequence with given element sort. + */ + public Term mkEmptySequence(Sort sort) + { + long termPointer = mkEmptySequence(pointer, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long mkEmptySequence(long pointer, long sortPointer); + + /** + * Create a universe set of the given sort. + * @param sort the sort of the set elements + * @return the universe set constant + */ + public Term mkUniverseSet(Sort sort) + { + long termPointer = mkUniverseSet(pointer, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long mkUniverseSet(long pointer, long sortPointer); + + /** + * Create a bit-vector constant of given size and value = 0. + * @param size the bit-width of the bit-vector sort + * @return the bit-vector constant + */ + public Term mkBitVector(int size) throws CVC5ApiException + { + return mkBitVector(size, 0); + } + + /** + * Create a bit-vector constant of given size and value. + * + * Note: The given value must fit into a bit-vector of the given size. + * + * @param size the bit-width of the bit-vector sort + * @param val the value of the constant + * @return the bit-vector constant + */ + public Term mkBitVector(int size, long val) throws CVC5ApiException + { + Utils.validateUnsigned(size, "size"); + Utils.validateUnsigned(val, "val"); + long termPointer = mkBitVector(pointer, size, val); + return new Term(this, termPointer); + } + + private native long mkBitVector(long pointer, int size, long val); + + /** + * Create a bit-vector constant of a given bit-width from a given string of + * base 2, 10 or 16. + * + * Note: The given value must fit into a bit-vector of the given size. + * + * @param size the bit-width of the constant + * @param s the string representation of the constant + * @param base the base of the string representation (2, 10, or 16) + * @return the bit-vector constant + */ + public Term mkBitVector(int size, String s, int base) throws CVC5ApiException + { + Utils.validateUnsigned(size, "size"); + Utils.validateUnsigned(base, "base"); + long termPointer = mkBitVector(pointer, size, s, base); + return new Term(this, termPointer); + } + + private native long mkBitVector(long pointer, int size, String s, int base); + + /** + * Create a constant array with the provided constant value stored at + * every index + * @param sort the sort of the constant array (must be an array sort) + * @param val the constant value to store (must match the sort's element + * sort) + * @return the constant array term + */ + public Term mkConstArray(Sort sort, Term val) + { + long termPointer = mkConstArray(pointer, sort.getPointer(), val.getPointer()); + return new Term(this, termPointer); + } + + private native long mkConstArray(long pointer, long sortPointer, long valPointer); + /** + * Create a positive infinity floating-point constant. + * @param exp Number of bits in the exponent + * @param sig Number of bits in the significand + * @return the floating-point constant + */ + public Term mkPosInf(int exp, int sig) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long termPointer = mkPosInf(pointer, exp, sig); + return new Term(this, termPointer); + } + + private native long mkPosInf(long pointer, int exp, int sig); + /** + * Create a negative infinity floating-point constant. + * @param exp Number of bits in the exponent + * @param sig Number of bits in the significand + * @return the floating-point constant + */ + public Term mkNegInf(int exp, int sig) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long termPointer = mkNegInf(pointer, exp, sig); + return new Term(this, termPointer); + } + + private native long mkNegInf(long pointer, int exp, int sig); + /** + * Create a not-a-number (NaN) floating-point constant. + * @param exp Number of bits in the exponent + * @param sig Number of bits in the significand + * @return the floating-point constant + */ + public Term mkNaN(int exp, int sig) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long termPointer = mkNaN(pointer, exp, sig); + return new Term(this, termPointer); + } + + private native long mkNaN(long pointer, int exp, int sig); + + /** + * Create a positive zero (+0.0) floating-point constant. + * @param exp Number of bits in the exponent + * @param sig Number of bits in the significand + * @return the floating-point constant + */ + public Term mkPosZero(int exp, int sig) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long termPointer = mkPosZero(pointer, exp, sig); + return new Term(this, termPointer); + } + + private native long mkPosZero(long pointer, int exp, int sig); + + /** + * Create a negative zero (-0.0) floating-point constant. + * @param exp Number of bits in the exponent + * @param sig Number of bits in the significand + * @return the floating-point constant + */ + public Term mkNegZero(int exp, int sig) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long termPointer = mkNegZero(pointer, exp, sig); + return new Term(this, termPointer); + } + + private native long mkNegZero(long pointer, int exp, int sig); + + /** + * Create a roundingmode constant. + * @param rm the floating point rounding mode this constant represents + */ + public Term mkRoundingMode(RoundingMode rm) + { + long termPointer = mkRoundingMode(pointer, rm.getValue()); + return new Term(this, termPointer); + } + + private native long mkRoundingMode(long pointer, int rm); + + /** + * Create uninterpreted constant. + * @param sort Sort of the constant + * @param index Index of the constant + */ + public Term mkUninterpretedConst(Sort sort, int index) throws CVC5ApiException + { + Utils.validateUnsigned(index, "index"); + long termPointer = mkUninterpretedConst(pointer, sort.getPointer(), index); + return new Term(this, termPointer); + } + + private native long mkUninterpretedConst(long pointer, long sortPointer, int index); + + /** + * Create an abstract value constant. + * @param index Index of the abstract value + */ + public Term mkAbstractValue(String index) + { + long termPointer = mkAbstractValue(pointer, index); + return new Term(this, termPointer); + } + + private native long mkAbstractValue(long pointer, String index); + + /** + * Create an abstract value constant. + * @param index Index of the abstract value + */ + public Term mkAbstractValue(long index) throws CVC5ApiException + { + Utils.validateUnsigned(index, "index"); + long termPointer = mkAbstractValue(pointer, index); + return new Term(this, termPointer); + } + + private native long mkAbstractValue(long pointer, long index); + + /** + * Create a floating-point constant. + * @param exp Size of the exponent + * @param sig Size of the significand + * @param val Value of the floating-point constant as a bit-vector term + */ + public Term mkFloatingPoint(int exp, int sig, Term val) throws CVC5ApiException + { + Utils.validateUnsigned(exp, "exp"); + Utils.validateUnsigned(sig, "sig"); + long termPointer = mkFloatingPoint(pointer, exp, sig, val.getPointer()); + return new Term(this, termPointer); + } + + private native long mkFloatingPoint(long pointer, int exp, int sig, long valPointer); + + /* .................................................................... */ + /* Create Variables */ + /* .................................................................... */ + + /** + * Create (first-order) constant (0-arity function symbol). + * SMT-LIB: + * \verbatim + * ( declare-const <symbol> <sort> ) + * ( declare-fun <symbol> ( ) <sort> ) + * \endverbatim * - * @param logic - * @throws CVC5ApiException + * @param sort the sort of the constant + * @param symbol the name of the constant + * @return the first-order constant + */ + public Term mkConst(Sort sort, String symbol) + { + long termPointer = mkConst(pointer, sort.getPointer(), symbol); + return new Term(this, termPointer); + } + + private native long mkConst(long pointer, long sortPointer, String symbol); + + /** + * Create (first-order) constant (0-arity function symbol), with a default + * symbol name. + * + * @param sort the sort of the constant + * @return the first-order constant + */ + public Term mkConst(Sort sort) + { + long termPointer = mkConst(pointer, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long mkConst(long pointer, long sortPointer); + + /** + * Create a bound variable to be used in a binder (i.e. a quantifier, a + * lambda, or a witness binder). + * @param sort the sort of the variable + * @return the variable + */ + public Term mkVar(Sort sort) + { + return mkVar(sort, ""); + } + + /** + * Create a bound variable to be used in a binder (i.e. a quantifier, a + * lambda, or a witness binder). + * @param sort the sort of the variable + * @param symbol the name of the variable + * @return the variable + */ + public Term mkVar(Sort sort, String symbol) + { + long termPointer = mkVar(pointer, sort.getPointer(), symbol); + return new Term(this, termPointer); + } + + private native long mkVar(long pointer, long sortPointer, String symbol); + + /* .................................................................... */ + /* Create datatype constructor declarations */ + /* .................................................................... */ + + public DatatypeConstructorDecl mkDatatypeConstructorDecl(String name) + { + long declPointer = mkDatatypeConstructorDecl(pointer, name); + return new DatatypeConstructorDecl(this, declPointer); + } + + private native long mkDatatypeConstructorDecl(long pointer, String name); + + /* .................................................................... */ + /* Create datatype declarations */ + /* .................................................................... */ + + /** + * Create a datatype declaration. + * @param name the name of the datatype + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name) + { + return mkDatatypeDecl(name, false); + } + + /** + * Create a datatype declaration. + * @param name the name of the datatype + * @param isCoDatatype true if a codatatype is to be constructed + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name, boolean isCoDatatype) + { + long declPointer = mkDatatypeDecl(pointer, name, isCoDatatype); + return new DatatypeDecl(this, declPointer); + } + + private native long mkDatatypeDecl(long pointer, String name, boolean isCoDatatype); + + /** + * Create a datatype declaration. + * Create sorts parameter with Solver::mkParamSort(). + * @param name the name of the datatype + * @param param the sort parameter + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name, Sort param) + { + return mkDatatypeDecl(name, param, false); + } + + /** + * Create a datatype declaration. + * Create sorts parameter with Solver::mkParamSort(). + * @param name the name of the datatype + * @param param the sort parameter + * @param isCoDatatype true if a codatatype is to be constructed + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name, Sort param, boolean isCoDatatype) + { + long declPointer = mkDatatypeDecl(pointer, name, param.getPointer(), isCoDatatype); + return new DatatypeDecl(this, declPointer); + } + + private native long mkDatatypeDecl( + long pointer, String name, long paramPointer, boolean isCoDatatype); + + /** + * Create a datatype declaration. + * Create sorts parameter with Solver::mkParamSort(). + * @param name the name of the datatype + * @param params a list of sort parameters + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name, List<Sort> params) + { + return mkDatatypeDecl(name, params.toArray(new Sort[0])); + } + + /** + * Create a datatype declaration. + * Create sorts parameter with Solver::mkParamSort(). + * @param name the name of the datatype + * @param params a list of sort parameters + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name, Sort[] params) + { + return mkDatatypeDecl(name, params, false); + } + + /** + * Create a datatype declaration. + * Create sorts parameter with Solver::mkParamSort(). + * @param name the name of the datatype + * @param params a list of sort parameters + * @param isCoDatatype true if a codatatype is to be constructed + * @return the DatatypeDecl + */ + public DatatypeDecl mkDatatypeDecl(String name, Sort[] params, boolean isCoDatatype) + { + long[] paramPointers = Utils.getPointers(params); + long declPointer = mkDatatypeDecl(pointer, name, paramPointers, isCoDatatype); + return new DatatypeDecl(this, declPointer); + } + + private native long mkDatatypeDecl( + long pointer, String name, long[] paramPointers, boolean isCoDatatype); + + /* .................................................................... */ + /* Formula Handling */ + /* .................................................................... */ + + /** + * Simplify a formula without doing "much" work. Does not involve + * the SAT Engine in the simplification, but uses the current + * definitions, assertions, and the current partial model, if one + * has been constructed. It also involves theory normalization. + * @param t the formula to simplify + * @return the simplified formula + */ + public Term simplify(Term t) + { + long termPointer = simplify(pointer, t.getPointer()); + return new Term(this, termPointer); + } + + private native long simplify(long pointer, long termPointer); + + /** + * Assert a formula. + * SMT-LIB: + * \verbatim + * ( assert <term> ) + * \endverbatim + * @param term the formula to assert + */ + public void assertFormula(Term term) + { + assertFormula(pointer, term.getPointer()); + } + + private native void assertFormula(long pointer, long termPointer); + + /** + * Check satisfiability. + * SMT-LIB: + * \verbatim + * ( check-sat ) + * \endverbatim + * @return the result of the satisfiability check. + */ + public Result checkSat() + { + long resultPointer = checkSat(pointer); + return new Result(this, resultPointer); + } + + private native long checkSat(long pointer); + /** + * Check satisfiability assuming the given formula. + * SMT-LIB: + * \verbatim + * ( check-sat-assuming ( <prop_literal> ) ) + * \endverbatim + * @param assumption the formula to assume + * @return the result of the satisfiability check. + */ + public Result checkSatAssuming(Term assumption) + { + long resultPointer = checkSatAssuming(pointer, assumption.getPointer()); + return new Result(this, resultPointer); + } + + private native long checkSatAssuming(long pointer, long assumptionPointer); + + /** + * Check satisfiability assuming the given formulas. + * SMT-LIB: + * \verbatim + * ( check-sat-assuming ( <prop_literal>+ ) ) + * \endverbatim + * @param assumptions the formulas to assume + * @return the result of the satisfiability check. + */ + public Result checkSatAssuming(Term[] assumptions) + { + long[] pointers = Utils.getPointers(assumptions); + long resultPointer = checkSatAssuming(pointer, pointers); + return new Result(this, resultPointer); + } + + private native long checkSatAssuming(long pointer, long[] assumptionPointers); + + /** + * Check entailment of the given formula w.r.t. the current set of assertions. + * @param term the formula to check entailment for + * @return the result of the entailment check. + */ + public Result checkEntailed(Term term) + { + long resultPointer = checkEntailed(pointer, term.getPointer()); + return new Result(this, resultPointer); + } + + private native long checkEntailed(long pointer, long termPointer); + + /** + * Check entailment of the given set of given formulas w.r.t. the current + * set of assertions. + * @param terms the terms to check entailment for + * @return the result of the entailmentcheck. + */ + public Result checkEntailed(Term[] terms) + { + long[] pointers = Utils.getPointers(terms); + long resultPointer = checkEntailed(pointer, pointers); + return new Result(this, resultPointer); + } + + private native long checkEntailed(long pointer, long[] termPointers); + + /** + * Create datatype sort. + * SMT-LIB: + * \verbatim + * ( declare-datatype <symbol> <datatype_decl> ) + * \endverbatim + * @param symbol the name of the datatype sort + * @param ctors the constructor declarations of the datatype sort + * @return the datatype sort + */ + public Sort declareDatatype(String symbol, DatatypeConstructorDecl[] ctors) + { + long[] pointers = Utils.getPointers(ctors); + long sortPointer = declareDatatype(pointer, symbol, pointers); + return new Sort(this, sortPointer); + } + + private native long declareDatatype(long pointer, String symbol, long[] declPointers); + + /** + * Declare n-ary function symbol. + * SMT-LIB: + * \verbatim + * ( declare-fun <symbol> ( <sort>* ) <sort> ) + * \endverbatim + * @param symbol the name of the function + * @param sorts the sorts of the parameters to this function + * @param sort the sort of the return value of this function + * @return the function + */ + public Term declareFun(String symbol, Sort[] sorts, Sort sort) + { + long[] sortPointers = Utils.getPointers(sorts); + long termPointer = declareFun(pointer, symbol, sortPointers, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long declareFun( + long pointer, String symbol, long[] sortPointers, long sortPointer); + + /** + * Declare uninterpreted sort. + * SMT-LIB: + * \verbatim + * ( declare-sort <symbol> <numeral> ) + * \endverbatim + * @param symbol the name of the sort + * @param arity the arity of the sort + * @return the sort + */ + public Sort declareSort(String symbol, int arity) throws CVC5ApiException + { + Utils.validateUnsigned(arity, "arity"); + long sortPointer = declareSort(pointer, symbol, arity); + return new Sort(this, sortPointer); + } + + private native long declareSort(long pointer, String symbol, int arity); + + /** + * Define n-ary function in the current context. + * SMT-LIB: + * \verbatim + * ( define-fun <function_def> ) + * \endverbatim + * @param symbol the name of the function + * @param boundVars the parameters to this function + * @param sort the sort of the return value of this function + * @param term the function body + * @return the function + */ + public Term defineFun(String symbol, Term[] boundVars, Sort sort, Term term) + { + return defineFun(symbol, boundVars, sort, term, false); + } + + /** + * Define n-ary function. + * SMT-LIB: + * \verbatim + * ( define-fun <function_def> ) + * \endverbatim + * @param symbol the name of the function + * @param boundVars the parameters to this function + * @param sort the sort of the return value of this function + * @param term the function body + * @param global determines whether this definition is global (i.e. persists + * when popping the context) + * @return the function + */ + public Term defineFun(String symbol, Term[] boundVars, Sort sort, Term term, boolean global) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = + defineFun(pointer, symbol, boundVarPointers, sort.getPointer(), term.getPointer(), global); + return new Term(this, termPointer); + } + + private native long defineFun(long pointer, + String symbol, + long[] boundVarPointers, + long sortPointer, + long termPointer, + boolean global); + + /** + * Define n-ary function in the current context. + * SMT-LIB: + * \verbatim + * ( define-fun <function_def> ) + * \endverbatim + * Create parameter 'fun' with mkConst(). + * @param fun the sorted function + * @param boundVars the parameters to this function + * @param term the function body + * @return the function + */ + public Term defineFun(Term fun, Term[] boundVars, Term term) + { + return defineFun(fun, boundVars, term, false); + } + /** + * Define n-ary function. + * SMT-LIB: + * \verbatim + * ( define-fun <function_def> ) + * \endverbatim + * Create parameter 'fun' with mkConst(). + * @param fun the sorted function + * @param boundVars the parameters to this function + * @param term the function body + * @param global determines whether this definition is global (i.e. persists + * when popping the context) + * @return the function + */ + public Term defineFun(Term fun, Term[] boundVars, Term term, boolean global) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = + defineFun(pointer, fun.getPointer(), boundVarPointers, term.getPointer(), global); + return new Term(this, termPointer); + } + + private native long defineFun( + long pointer, long funPointer, long[] boundVarPointers, long termPointer, boolean global); + + /** + * Define recursive function in the current context. + * SMT-LIB: + * \verbatim + * ( define-fun-rec <function_def> ) + * \endverbatim + * @param symbol the name of the function + * @param boundVars the parameters to this function + * @param sort the sort of the return value of this function + * @param term the function body + * @return the function + */ + public Term defineFunRec(String symbol, Term[] boundVars, Sort sort, Term term) + { + return defineFunRec(symbol, boundVars, sort, term, false); + } + + /** + * Define recursive function. + * SMT-LIB: + * \verbatim + * ( define-fun-rec <function_def> ) + * \endverbatim + * @param symbol the name of the function + * @param boundVars the parameters to this function + * @param sort the sort of the return value of this function + * @param term the function body + * @param global determines whether this definition is global (i.e. persists + * when popping the context) + * @return the function + */ + public Term defineFunRec(String symbol, Term[] boundVars, Sort sort, Term term, boolean global) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = defineFunRec( + pointer, symbol, boundVarPointers, sort.getPointer(), term.getPointer(), global); + return new Term(this, termPointer); + } + + private native long defineFunRec(long pointer, + String symbol, + long[] boundVarPointers, + long sortPointer, + long termPointer, + boolean global); + + /** + * Define recursive function in the current context. + * SMT-LIB: + * \verbatim + * ( define-fun-rec <function_def> ) + * \endverbatim + * Create parameter 'fun' with mkConst(). + * @param fun the sorted function + * @param boundVars the parameters to this function + * @param term the function body + * @return the function + */ + + public Term defineFunRec(Term fun, Term[] boundVars, Term term) + { + return defineFunRec(fun, boundVars, term, false); + } + + /** + * Define recursive function. + * SMT-LIB: + * \verbatim + * ( define-fun-rec <function_def> ) + * \endverbatim + * Create parameter 'fun' with mkConst(). + * @param fun the sorted function + * @param boundVars the parameters to this function + * @param term the function body + * @param global determines whether this definition is global (i.e. persists + * when popping the context) + * @return the function + */ + public Term defineFunRec(Term fun, Term[] boundVars, Term term, boolean global) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = + defineFunRec(pointer, fun.getPointer(), boundVarPointers, term.getPointer(), global); + return new Term(this, termPointer); + } + + private native long defineFunRec( + long pointer, long funPointer, long[] boundVarPointers, long termPointer, boolean global); + + /** + * Define recursive functions in the current context. + * SMT-LIB: + * \verbatim + * ( define-funs-rec ( <function_decl>^{n+1} ) ( <term>^{n+1} ) ) + * \endverbatim + * Create elements of parameter 'funs' with mkConst(). + * @param funs the sorted functions + * @param boundVars the list of parameters to the functions + * @param terms the list of function bodies of the functions + * @return the function + */ + public void defineFunsRec(Term[] funs, Term[][] boundVars, Term[] terms) + { + defineFunsRec(funs, boundVars, terms, false); + } + /** + * Define recursive functions. + * SMT-LIB: + * \verbatim + * ( define-funs-rec ( <function_decl>^{n+1} ) ( <term>^{n+1} ) ) + * \endverbatim + * Create elements of parameter 'funs' with mkConst(). + * @param funs the sorted functions + * @param boundVars the list of parameters to the functions + * @param terms the list of function bodies of the functions + * @param global determines whether this definition is global (i.e. persists + * when popping the context) + * @return the function + */ + public void defineFunsRec(Term[] funs, Term[][] boundVars, Term[] terms, boolean global) + { + long[] funPointers = Utils.getPointers(funs); + long[][] boundVarPointers = Utils.getPointers(boundVars); + long[] termPointers = Utils.getPointers(terms); + defineFunsRec(pointer, funPointers, boundVarPointers, termPointers, global); + } + + private native void defineFunsRec(long pointer, + long[] funPointers, + long[][] boundVarPointers, + long[] termPointers, + boolean global); + + /** + * Echo a given string to the given output stream. + * SMT-LIB: + * \verbatim + * ( echo <std::string> ) + * \endverbatim + * @param out the output stream + * @param str the string to echo + */ + // TODO: void echo(std::ostream& out, String str) + + /** + * Get the list of asserted formulas. + * SMT-LIB: + * \verbatim + * ( get-assertions ) + * \endverbatim + * @return the list of asserted formulas + */ + public Term[] getAssertions() + { + long[] retPointers = getAssertions(pointer); + return Utils.getTerms(this, retPointers); + } + + private native long[] getAssertions(long pointer); + + /** + * Get info from the solver. + * SMT-LIB: \verbatim( get-info <info_flag> )\verbatim + * @return the info + */ + public String getInfo(String flag) + { + return getInfo(pointer, flag); + } + + private native String getInfo(long pointer, String flag); + + /** + * Get the value of a given option. + * SMT-LIB: + * \verbatim + * ( get-option <keyword> ) + * \endverbatim + * @param option the option for which the value is queried + * @return a string representation of the option value + */ + public String getOption(String option) + { + return getOption(pointer, option); + } + + private native String getOption(long pointer, String option); + + /** + * Get the set of unsat ("failed") assumptions. + * SMT-LIB: + * \verbatim + * ( get-unsat-assumptions ) + * \endverbatim + * Requires to enable option 'produce-unsat-assumptions'. + * @return the set of unsat assumptions. + */ + public Term[] getUnsatAssumptions() + { + long[] retPointers = getUnsatAssumptions(pointer); + return Utils.getTerms(this, retPointers); + } + + private native long[] getUnsatAssumptions(long pointer); + + /** + * Get the unsatisfiable core. + * SMT-LIB: + * \verbatim + * ( get-unsat-core ) + * \endverbatim + * Requires to enable option 'produce-unsat-cores'. + * @return a set of terms representing the unsatisfiable core + */ + public Term[] getUnsatCore() + { + long[] retPointers = getUnsatCore(pointer); + return Utils.getTerms(this, retPointers); + } + + private native long[] getUnsatCore(long pointer); + + /** + * Get the value of the given term. + * SMT-LIB: + * \verbatim + * ( get-value ( <term> ) ) + * \endverbatim + * @param term the term for which the value is queried + * @return the value of the given term + */ + public Term getValue(Term term) + { + long termPointer = getValue(pointer, term.getPointer()); + return new Term(this, termPointer); + } + + private native long getValue(long pointer, long termPointer); + + /** + * Get the values of the given terms. + * SMT-LIB: + * \verbatim + * ( get-value ( <term>+ ) ) + * \endverbatim + * @param terms the terms for which the value is queried + * @return the values of the given terms + */ + public Term[] getValue(Term[] terms) + { + long[] pointers = Utils.getPointers(terms); + long[] retPointers = getValue(pointer, pointers); + return Utils.getTerms(this, retPointers); + } + + private native long[] getValue(long pointer, long[] termPointers); + + /** + * This returns false if the model value of free constant v was not essential + * for showing the satisfiability of the last call to checkSat using the + * current model. This method will only return false (for any v) if + * the model-cores option has been set. + * + * @param v The term in question + * @return true if v is a model core symbol + */ + public boolean isModelCoreSymbol(Term v) + { + return isModelCoreSymbol(pointer, v.getPointer()); + } + + private native boolean isModelCoreSymbol(long pointer, long termPointer); + + /** + * Get the model + * SMT-LIB: + * \verbatim + * ( get-model ) + * \endverbatim + * Requires to enable option 'produce-models'. + * @param sorts The list of uninterpreted sorts that should be printed in the + * model. + * @param vars The list of free constants that should be printed in the + * model. A subset of these may be printed based on isModelCoreSymbol. + * @return a string representing the model. + */ + public String getModel(Sort[] sorts, Term[] vars) + { + long[] sortPointers = Utils.getPointers(sorts); + long[] varPointers = Utils.getPointers(vars); + return getModel(pointer, sortPointers, varPointers); + } + + private native String getModel(long pointer, long[] sortPointers, long[] varPointers); + + /** + * Do quantifier elimination. + * SMT-LIB: + * \verbatim + * ( get-qe <q> ) + * \endverbatim + * Requires a logic that supports quantifier elimination. Currently, the only + * logics supported by quantifier elimination is LRA and LIA. + * @param q a quantified formula of the form: + * Q x1...xn. P( x1...xn, y1...yn ) + * where P( x1...xn, y1...yn ) is a quantifier-free formula + * @return a formula ret such that, given the current set of formulas A + * asserted to this solver: + * - ( A ^ q ) and ( A ^ ret ) are equivalent + * - ret is quantifier-free formula containing only free variables in + * y1...yn. + */ + public Term getQuantifierElimination(Term q) + { + long termPointer = getQuantifierElimination(pointer, q.getPointer()); + return new Term(this, termPointer); + } + + private native long getQuantifierElimination(long pointer, long qPointer); + + /** + * Do partial quantifier elimination, which can be used for incrementally + * computing the result of a quantifier elimination. + * SMT-LIB: + * \verbatim + * ( get-qe-disjunct <q> ) + * \endverbatim + * Requires a logic that supports quantifier elimination. Currently, the only + * logics supported by quantifier elimination is LRA and LIA. + * @param q a quantified formula of the form: + * Q x1...xn. P( x1...xn, y1...yn ) + * where P( x1...xn, y1...yn ) is a quantifier-free formula + * @return a formula ret such that, given the current set of formulas A + * asserted to this solver: + * - (A ^ q) => (A ^ ret) if Q is forall or (A ^ ret) => (A ^ q) if Q is + * exists, + * - ret is quantifier-free formula containing only free variables in + * y1...yn, + * - If Q is exists, let A^Q_n be the formula + * A ^ ~ret^Q_1 ^ ... ^ ~ret^Q_n + * where for each i=1,...n, formula ret^Q_i is the result of calling + * getQuantifierEliminationDisjunct for q with the set of assertions + * A^Q_{i-1}. Similarly, if Q is forall, then let A^Q_n be + * A ^ ret^Q_1 ^ ... ^ ret^Q_n + * where ret^Q_i is the same as above. In either case, we have + * that ret^Q_j will eventually be true or false, for some finite j. + */ + public Term getQuantifierEliminationDisjunct(Term q) + { + long termPointer = getQuantifierEliminationDisjunct(pointer, q.getPointer()); + return new Term(this, termPointer); + } + + private native long getQuantifierEliminationDisjunct(long pointer, long qPointer); + + /** + * When using separation logic, this sets the location sort and the + * datatype sort to the given ones. This method should be invoked exactly + * once, before any separation logic constraints are provided. + * @param locSort The location sort of the heap + * @param dataSort The data sort of the heap + */ + public void declareSeparationHeap(Sort locSort, Sort dataSort) + { + declareSeparationHeap(pointer, locSort.getPointer(), dataSort.getPointer()); + } + + private native void declareSeparationHeap( + long pointer, long locSortPointer, long dataSortPointer); + + /** + * When using separation logic, obtain the term for the heap. + * @return The term for the heap + */ + public Term getSeparationHeap() + { + long termPointer = getSeparationHeap(pointer); + return new Term(this, termPointer); + } + + private native long getSeparationHeap(long pointer); + + /** + * When using separation logic, obtain the term for nil. + * @return The term for nil + */ + public Term getSeparationNilTerm() + { + long termPointer = getSeparationNilTerm(pointer); + return new Term(this, termPointer); + } + + private native long getSeparationNilTerm(long pointer); + + /** + * Pop a level from the assertion stack. + * SMT-LIB: + * \verbatim + * ( pop <numeral> ) + * \endverbatim + */ + public void pop() throws CVC5ApiException + { + pop(1); + } + + /** + * Pop (a) level(s) from the assertion stack. + * SMT-LIB: + * \verbatim + * ( pop <numeral> ) + * \endverbatim + * @param nscopes the number of levels to pop + */ + public void pop(int nscopes) throws CVC5ApiException + { + Utils.validateUnsigned(nscopes, "nscopes"); + pop(pointer, nscopes); + } + + private native void pop(long pointer, int nscopes); + + /** + * Get an interpolant + * SMT-LIB: + * \verbatim + * ( get-interpol <conj> ) + * \endverbatim + * Requires to enable option 'produce-interpols'. + * @param conj the conjecture term + * @param output a Term I such that A->I and I->B are valid, where A is the + * current set of assertions and B is given in the input by conj. + * @return true if it gets I successfully, false otherwise. + */ + public boolean getInterpolant(Term conj, Term output) + { + return getInterpolant(pointer, conj.getPointer(), output.getPointer()); + } + + private native boolean getInterpolant(long pointer, long conjPointer, long outputPointer); + + /** + * Get an interpolant + * SMT-LIB: + * \verbatim + * ( get-interpol <conj> <g> ) + * \endverbatim + * Requires to enable option 'produce-interpols'. + * @param conj the conjecture term + * @param grammar the grammar for the interpolant I + * @param output a Term I such that A->I and I->B are valid, where A is the + * current set of assertions and B is given in the input by conj. + * @return true if it gets I successfully, false otherwise. + */ + public boolean getInterpolant(Term conj, Grammar grammar, Term output) + { + return getInterpolant(pointer, conj.getPointer(), grammar.getPointer(), output.getPointer()); + } + + private native boolean getInterpolant( + long pointer, long conjPointer, long grammarPointer, long outputPointer); + + /** + * Get an abduct. + * SMT-LIB: + * \verbatim + * ( get-abduct <conj> ) + * \endverbatim + * Requires enabling option 'produce-abducts' + * @param conj the conjecture term + * @param output a term C such that A^C is satisfiable, and A^~B^C is + * unsatisfiable, where A is the current set of assertions and B is + * given in the input by conj + * @return true if it gets C successfully, false otherwise + */ + public boolean getAbduct(Term conj, Term output) + { + return getAbduct(pointer, conj.getPointer(), output.getPointer()); + } + + private native boolean getAbduct(long pointer, long conjPointer, long outputPointer); + /** + * Get an abduct. + * SMT-LIB: + * \verbatim + * ( get-abduct <conj> <g> ) + * \endverbatim + * Requires enabling option 'produce-abducts' + * @param conj the conjecture term + * @param grammar the grammar for the abduct C + * @param output a term C such that A^C is satisfiable, and A^~B^C is + * unsatisfiable, where A is the current set of assertions and B is + * given in the input by conj + * @return true if it gets C successfully, false otherwise + */ + public boolean getAbduct(Term conj, Grammar grammar, Term output) + { + return getAbduct(pointer, conj.getPointer(), grammar.getPointer(), output.getPointer()); + } + + private native boolean getAbduct( + long pointer, long conjPointer, long grammarPointer, long outputPointer); + + /** + * Block the current model. Can be called only if immediately preceded by a + * SAT or INVALID query. + * SMT-LIB: + * \verbatim + * ( block-model ) + * \endverbatim + * Requires enabling 'produce-models' option and setting 'block-models' option + * to a mode other than "none". + */ + public void blockModel() + { + blockModel(pointer); + } + + private native void blockModel(long pointer); + + /** + * Block the current model values of (at least) the values in terms. Can be + * called only if immediately preceded by a SAT or NOT_ENTAILED query. + * SMT-LIB: + * \verbatim + * ( block-model-values ( <terms>+ ) ) + * \endverbatim + * Requires enabling 'produce-models' option and setting 'block-models' option + * to a mode other than "none". + */ + public void blockModelValues(Term[] terms) + { + long[] pointers = Utils.getPointers(terms); + blockModelValues(pointer, pointers); + } + + private native void blockModelValues(long pointer, long[] termPointers); + + /** + * Print all instantiations made by the quantifiers module. + * @param out the output stream + */ + // TODO: void printInstantiations(std::ostream& out) + + /** + * Push a level to the assertion stack. + * SMT-LIB: + * \verbatim + * ( push <numeral> ) + * \endverbatim + */ + public void push() throws CVC5ApiException + { + push(1); + } + + /** + * Push (a) level(s) to the assertion stack. + * SMT-LIB: + * \verbatim + * ( push <numeral> ) + * \endverbatim + * @param nscopes the number of levels to push + */ + public void push(int nscopes) throws CVC5ApiException + { + Utils.validateUnsigned(nscopes, "nscopes"); + push(pointer, nscopes); + } + + private native void push(long pointer, int nscopes); + + /** + * Remove all assertions. + * SMT-LIB: + * \verbatim + * ( reset-assertions ) + * \endverbatim + */ + public void resetAssertions() + { + resetAssertions(pointer); + } + + private native void resetAssertions(long pointer); + + /** + * Set info. + * SMT-LIB: + * \verbatim + * ( set-info <attribute> ) + * \endverbatim + * @param keyword the info flag + * @param value the value of the info flag + */ + public void setInfo(String keyword, String value) throws CVC5ApiException + { + setInfo(pointer, keyword, value); + } + + private native void setInfo(long pointer, String keyword, String value) throws CVC5ApiException; + + /** + * Set logic. + * SMT-LIB: + * \verbatim + * ( set-logic <symbol> ) + * \endverbatim + * @param logic the logic to set */ public void setLogic(String logic) throws CVC5ApiException { setLogic(pointer, logic); } - private native void setLogic(long solverPointer, String logic) throws CVC5ApiException; + private native void setLogic(long pointer, String logic) throws CVC5ApiException; + + /** + * Set option. + * SMT-LIB: + * \verbatim + * ( set-option <option> ) + * \endverbatim + * @param option the option name + * @param value the option value + */ + public void setOption(String option, String value) + { + setOption(pointer, option, value); + } + + private native void setOption(long pointer, String option, String value); + + /** + * If needed, convert this term to a given sort. Note that the sort of the + * term must be convertible into the target sort. Currently only Int to Real + * conversions are supported. + * @param t the term + * @param s the target sort + * @return the term wrapped into a sort conversion if needed + */ + public Term ensureTermSort(Term t, Sort s) + { + long termPointer = ensureTermSort(pointer, t.getPointer(), s.getPointer()); + return new Term(this, termPointer); + } + + private native long ensureTermSort(long pointer, long termPointer, long sortPointer); + + /** + * Append \p symbol to the current list of universal variables. + * @param sort the sort of the universal variable + * @return the universal variable + */ + public Term mkSygusVar(Sort sort) + { + return mkSygusVar(sort, ""); + } + /** + * Append \p symbol to the current list of universal variables. + * SyGuS v2: + * \verbatim + * ( declare-var <symbol> <sort> ) + * \endverbatim + * @param sort the sort of the universal variable + * @param symbol the name of the universal variable + * @return the universal variable + */ + public Term mkSygusVar(Sort sort, String symbol) + { + long termPointer = mkSygusVar(pointer, sort.getPointer(), symbol); + return new Term(this, termPointer); + } + + private native long mkSygusVar(long pointer, long sortPointer, String symbol); + + /** + * Create a Sygus grammar. The first non-terminal is treated as the starting + * non-terminal, so the order of non-terminals matters. + * + * @param boundVars the parameters to corresponding synth-fun/synth-inv + * @param ntSymbols the pre-declaration of the non-terminal symbols + * @return the grammar + */ + public Grammar mkSygusGrammar(Term[] boundVars, Term[] ntSymbols) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long[] ntSymbolPointers = Utils.getPointers(ntSymbols); + long grammarPointer = mkSygusGrammar(pointer, boundVarPointers, ntSymbolPointers); + return new Grammar(this, grammarPointer); + } + + private native long mkSygusGrammar( + long pointer, long[] boundVarPointers, long[] ntSymbolPointers); + + /** + * Synthesize n-ary function. + * SyGuS v2: + * \verbatim + * ( synth-fun <symbol> ( <boundVars>* ) <sort> ) + * \endverbatim + * @param symbol the name of the function + * @param boundVars the parameters to this function + * @param sort the sort of the return value of this function + * @return the function + */ + public Term synthFun(String symbol, Term[] boundVars, Sort sort) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = synthFun(pointer, symbol, boundVarPointers, sort.getPointer()); + return new Term(this, termPointer); + } + + private native long synthFun( + long pointer, String symbol, long[] boundVarPointers, long sortPointer); + + /** + * Synthesize n-ary function following specified syntactic constraints. + * SyGuS v2: + * \verbatim + * ( synth-fun <symbol> ( <boundVars>* ) <sort> <g> ) + * \endverbatim + * @param symbol the name of the function + * @param boundVars the parameters to this function + * @param sort the sort of the return value of this function + * @param grammar the syntactic constraints + * @return the function + */ + public Term synthFun(String symbol, Term[] boundVars, Sort sort, Grammar grammar) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = + synthFun(pointer, symbol, boundVarPointers, sort.getPointer(), grammar.getPointer()); + return new Term(this, termPointer); + } + + private native long synthFun( + long pointer, String symbol, long[] boundVarPointers, long sortPointer, long grammarPointer); + + /** + * Synthesize invariant. + * SyGuS v2: + * \verbatim + * ( synth-inv <symbol> ( <boundVars>* ) ) + * \endverbatim + * @param symbol the name of the invariant + * @param boundVars the parameters to this invariant + * @return the invariant + */ + public Term synthInv(String symbol, Term[] boundVars) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = synthInv(pointer, symbol, boundVarPointers); + return new Term(this, termPointer); + } + + private native long synthInv(long pointer, String symbol, long[] boundVarPointers); + + /** + * Synthesize invariant following specified syntactic constraints. + * SyGuS v2: + * \verbatim + * ( synth-inv <symbol> ( <boundVars>* ) <g> ) + * \endverbatim + * @param symbol the name of the invariant + * @param boundVars the parameters to this invariant + * @param grammar the syntactic constraints + * @return the invariant + */ + public Term synthInv(String symbol, Term[] boundVars, Grammar grammar) + { + long[] boundVarPointers = Utils.getPointers(boundVars); + long termPointer = synthInv(pointer, symbol, boundVarPointers, grammar.getPointer()); + return new Term(this, termPointer); + } + + private native long synthInv( + long pointer, String symbol, long[] boundVarPointers, long grammarPointer); + + /** + * Add a forumla to the set of Sygus constraints. + * SyGuS v2: + * \verbatim + * ( constraint <term> ) + * \endverbatim + * @param term the formula to add as a constraint + */ + public void addSygusConstraint(Term term) + { + addSygusConstraint(pointer, term.getPointer()); + } + + private native void addSygusConstraint(long pointer, long termPointer); + /** + * Add a set of Sygus constraints to the current state that correspond to an + * invariant synthesis problem. + * SyGuS v2: + * \verbatim + * ( inv-constraint <inv> <pre> <trans> <post> ) + * \endverbatim + * @param inv the function-to-synthesize + * @param pre the pre-condition + * @param trans the transition relation + * @param post the post-condition + */ + public void addSygusInvConstraint(Term inv, Term pre, Term trans, Term post) + { + addSygusInvConstraint( + pointer, inv.getPointer(), pre.getPointer(), trans.getPointer(), post.getPointer()); + } + + private native void addSygusInvConstraint( + long pointer, long invPointer, long prePointer, long transPointer, long postPointer); + + /** + * Try to find a solution for the synthesis conjecture corresponding to the + * current list of functions-to-synthesize, universal variables and + * constraints. + * SyGuS v2: + * \verbatim + * ( check-synth ) + * \endverbatim + * @return the result of the synthesis conjecture. + */ + public Result checkSynth() + { + long resultPointer = checkSynth(pointer); + return new Result(this, resultPointer); + } + + private native long checkSynth(long pointer); + + /** + * Get the synthesis solution of the given term. This method should be called + * immediately after the solver answers unsat for sygus input. + * @param term the term for which the synthesis solution is queried + * @return the synthesis solution of the given term + */ + public Term getSynthSolution(Term term) + { + long termPointer = getSynthSolution(pointer, term.getPointer()); + return new Term(this, termPointer); + } + + private native long getSynthSolution(long pointer, long termPointer); + + /** + * Get the synthesis solutions of the given terms. This method should be + * called immediately after the solver answers unsat for sygus input. + * @param terms the terms for which the synthesis solutions is queried + * @return the synthesis solutions of the given terms + */ + public Term[] getSynthSolutions(Term[] terms) + { + long[] termPointers = Utils.getPointers(terms); + long[] retPointers = getSynthSolutions(pointer, termPointers); + return Utils.getTerms(this, retPointers); + } + + private native long[] getSynthSolutions(long pointer, long[] termPointers); + + /** + * Print solution for synthesis conjecture to the given output stream. + * @param out the output stream + */ + // TODO: void printSynthSolution(std::ostream& out) + + /** + * @return null term + */ + public Term getNullTerm() + { + long termPointer = getNullTerm(pointer); + return new Term(this, termPointer); + } + + private native long getNullTerm(long pointer); + + /** + * @return null result + */ + public Result getNullResult() + { + long resultPointer = getNullResult(pointer); + return new Result(this, resultPointer); + } + + private native long getNullResult(long pointer); + + /** + * @return null op + */ + public Op getNullOp() + { + long opPointer = getNullOp(pointer); + return new Op(this, opPointer); + } + + private native long getNullOp(long pointer); + + /** + * @return null op + */ + public DatatypeDecl getNullDatatypeDecl() + { + long declPointer = getNullDatatypeDecl(pointer); + return new DatatypeDecl(this, declPointer); + } + + private native long getNullDatatypeDecl(long pointer); } diff --git a/src/api/java/cvc5/Sort.java b/src/api/java/cvc5/Sort.java index a52a249f8..f1f541e35 100644 --- a/src/api/java/cvc5/Sort.java +++ b/src/api/java/cvc5/Sort.java @@ -32,8 +32,7 @@ public class Sort extends AbstractPointer implements Comparable<Sort> return pointer; } - @Override - public void finalize() + @Override public void finalize() { deletePointer(pointer); } @@ -428,7 +427,7 @@ public class Sort extends AbstractPointer implements Comparable<Sort> * Create sorts parameter with Solver.mkParamSort(). * @param params the list of sort parameters to instantiate with */ - Sort instantiate(List<Sort> params) + public Sort instantiate(List<Sort> params) { return instantiate(params.toArray(new Sort[0])); } @@ -438,7 +437,7 @@ public class Sort extends AbstractPointer implements Comparable<Sort> * Create sorts parameter with Solver.mkParamSort(). * @param params the list of sort parameters to instantiate with */ - Sort instantiate(Sort[] params) + public Sort instantiate(Sort[] params) { long[] paramsPointers = Utils.getPointers(params); long sortPointer = instantiate(pointer, paramsPointers); @@ -465,7 +464,7 @@ public class Sort extends AbstractPointer implements Comparable<Sort> * @param sorts the subsorts to be substituted within this sort. * @param replacements the sort replacing the substituted subsorts. */ - Sort substitute(Sort[] sorts, Sort[] replacements) + public Sort substitute(Sort[] sorts, Sort[] replacements) { long[] sortPointers = Utils.getPointers(sorts); long[] replacementPointers = Utils.getPointers(sorts); @@ -513,7 +512,7 @@ public class Sort extends AbstractPointer implements Comparable<Sort> /** * @return the codomain sort of a constructor sort */ - Sort getConstructorCodomainSort() + public Sort getConstructorCodomainSort() { long sortPointer = getConstructorCodomainSort(pointer); return new Sort(solver, sortPointer); @@ -800,4 +799,4 @@ public class Sort extends AbstractPointer implements Comparable<Sort> } private native long[] getTupleSorts(long pointer); -} +}
\ No newline at end of file diff --git a/src/api/java/cvc5/Stat.java b/src/api/java/cvc5/Stat.java index 964f4025c..00ea50797 100644 --- a/src/api/java/cvc5/Stat.java +++ b/src/api/java/cvc5/Stat.java @@ -28,26 +28,25 @@ import java.util.Map; */ public class Stat extends AbstractPointer { - // region construction and destruction - Stat(Solver solver, long pointer) - { - super(solver, pointer); - } + // region construction and destruction + Stat(Solver solver, long pointer) + { + super(solver, pointer); + } - protected static native void deletePointer(long pointer); + protected static native void deletePointer(long pointer); - public long getPointer() - { - return pointer; - } + public long getPointer() + { + return pointer; + } - @Override - public void finalize() - { - deletePointer(pointer); - } + @Override public void finalize() + { + deletePointer(pointer); + } - // endregion + // endregion /** * @return a string representation of this Stat @@ -159,7 +158,7 @@ public class Stat extends AbstractPointer */ public Map<String, Long> getHistogram() { - return getHistogram(pointer); + return getHistogram(pointer); } private native Map<String, Long> getHistogram(long pointer); diff --git a/src/api/java/cvc5/Statistics.java b/src/api/java/cvc5/Statistics.java index ba4828284..a85220e21 100644 --- a/src/api/java/cvc5/Statistics.java +++ b/src/api/java/cvc5/Statistics.java @@ -20,33 +20,31 @@ import java.util.NoSuchElementException; public class Statistics extends AbstractPointer implements Iterable<Pair<String, Stat>> { - // region construction and destruction - Statistics(Solver solver, long pointer) - { - super(solver, pointer); - } + // region construction and destruction + Statistics(Solver solver, long pointer) + { + super(solver, pointer); + } - protected static native void deletePointer(long pointer); + protected static native void deletePointer(long pointer); - public long getPointer() - { - return pointer; - } + public long getPointer() + { + return pointer; + } - @Override - public void finalize() - { - deletePointer(pointer); - } + @Override public void finalize() + { + deletePointer(pointer); + } - // endregion + // endregion /** * @return a string representation of this Statistics */ protected native String toString(long pointer); - /** * Retrieve the statistic with the given name. * Asserts that a statistic with the given name actually exists and throws @@ -70,58 +68,54 @@ public class Statistics extends AbstractPointer implements Iterable<Pair<String, * @param defaulted If set to true, defaulted statistics are shown as well. */ + private native long getIterator(long pointer); + + private native boolean hasNext(long pointer, long iteratorPointer); - private native long getIterator(long pointer); - - private native boolean hasNext(long pointer, long iteratorPointer); - - private native Pair<String, Long> getNext(long pointer, long iteratorPointer) throws CVC5ApiException; - - private native long increment(long pointer, long iteratorPointer) throws CVC5ApiException; - - private native void deleteIteratorPointer(long iteratorPointer); - - public class ConstIterator implements Iterator<Pair<String, Stat>> - { - private long iteratorPointer = 0; - - public ConstIterator() - { - iteratorPointer = getIterator(pointer); - } - - @Override - public boolean hasNext() - { - return Statistics.this.hasNext(pointer, iteratorPointer); - } - - @Override - public Pair<String, Stat> next() - { - try - { - Pair<String, Long> pair = Statistics.this.getNext(pointer, iteratorPointer); - Stat stat = new Stat(solver, pair.second); - this.iteratorPointer = Statistics.this.increment(pointer, iteratorPointer); - return new Pair<>(pair.first, stat); - } - catch(CVC5ApiException e) - { - throw new NoSuchElementException(e.getMessage()); - } - } - - @Override - public void finalize() - { - deleteIteratorPointer(iteratorPointer); - } - } - - @Override - public Iterator<Pair<String, Stat>> iterator() - { - return new ConstIterator(); - } + private native Pair<String, Long> getNext(long pointer, long iteratorPointer) + throws CVC5ApiException; + + private native long increment(long pointer, long iteratorPointer) throws CVC5ApiException; + + private native void deleteIteratorPointer(long iteratorPointer); + + public class ConstIterator implements Iterator<Pair<String, Stat>> + { + private long iteratorPointer = 0; + + public ConstIterator() + { + iteratorPointer = getIterator(pointer); + } + + @Override public boolean hasNext() + { + return Statistics.this.hasNext(pointer, iteratorPointer); + } + + @Override public Pair<String, Stat> next() + { + try + { + Pair<String, Long> pair = Statistics.this.getNext(pointer, iteratorPointer); + Stat stat = new Stat(solver, pair.second); + this.iteratorPointer = Statistics.this.increment(pointer, iteratorPointer); + return new Pair<>(pair.first, stat); + } + catch (CVC5ApiException e) + { + throw new NoSuchElementException(e.getMessage()); + } + } + + @Override public void finalize() + { + deleteIteratorPointer(iteratorPointer); + } + } + + @Override public Iterator<Pair<String, Stat>> iterator() + { + return new ConstIterator(); + } }; diff --git a/src/api/java/cvc5/Term.java b/src/api/java/cvc5/Term.java index 276c288d1..ebf55116b 100644 --- a/src/api/java/cvc5/Term.java +++ b/src/api/java/cvc5/Term.java @@ -15,25 +15,28 @@ package cvc5; +import java.math.BigInteger; import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; -public class Term - extends AbstractPointer implements Comparable<Term>, Iterable<Term> { +public class Term extends AbstractPointer implements Comparable<Term>, Iterable<Term> +{ // region construction and destruction - Term(Solver solver, long pointer) { + Term(Solver solver, long pointer) + { super(solver, pointer); } protected static native void deletePointer(long pointer); - public long getPointer() { + public long getPointer() + { return pointer; } - @Override - public void finalize() { + @Override public void finalize() + { deletePointer(pointer); } @@ -47,14 +50,15 @@ public class Term * @param t the term to compare to for equality * @return true if the terms are equal */ - @Override - public boolean equals(Object t) { + @Override public boolean equals(Object t) + { if (this == t) return true; if (t == null || getClass() != t.getClass()) return false; Term term = (Term) t; - if (this.pointer == term.pointer) { + if (this.pointer == term.pointer) + { return true; } return equals(pointer, term.getPointer()); @@ -69,8 +73,8 @@ public class Term * @return a negative integer, zero, or a positive integer as this term * is less than, equal to, or greater than the specified term. */ - @Override - public int compareTo(Term t) { + @Override public int compareTo(Term t) + { return this.compareTo(pointer, t.getPointer()); } @@ -79,7 +83,8 @@ public class Term /** * @return the number of children of this term */ - public int getNumChildren() { + public int getNumChildren() + { return getNumChildren(pointer); } @@ -91,7 +96,8 @@ public class Term * @param index the index of the child term to return * @return the child term with the given index */ - public Term getChild(int index) throws CVC5ApiException { + public Term getChild(int index) throws CVC5ApiException + { Utils.validateUnsigned(index, "index"); long termPointer = getChild(pointer, index); return new Term(solver, termPointer); @@ -102,7 +108,8 @@ public class Term /** * @return the id of this term */ - public long getId() { + public long getId() + { return getId(pointer); } @@ -111,7 +118,8 @@ public class Term /** * @return the kind of this term */ - public Kind getKind() throws CVC5ApiException { + public Kind getKind() throws CVC5ApiException + { int value = getKind(pointer); return Kind.fromInt(value); } @@ -121,7 +129,8 @@ public class Term /** * @return the sort of this term */ - public Sort getSort() { + public Sort getSort() + { long sortPointer = getSort(pointer); return new Sort(solver, sortPointer); } @@ -131,35 +140,37 @@ public class Term /** * @return the result of replacing 'term' by 'replacement' in this term */ - public Term substitute(Term term, Term replacement) { - long termPointer = - substitute(pointer, term.getPointer(), replacement.getPointer()); + public Term substitute(Term term, Term replacement) + { + long termPointer = substitute(pointer, term.getPointer(), replacement.getPointer()); return new Term(solver, termPointer); } - private native long substitute( - long pointer, long termPointer, long replacementPointer); + private native long substitute(long pointer, long termPointer, long replacementPointer); /** * @return the result of simultaneously replacing 'terms' by 'replacements' * in this term */ - public Term substitute(List<Term> terms, List<Term> replacements) { - return substitute( - terms.toArray(new Term[0]), replacements.toArray(new Term[0])); + public Term substitute(List<Term> terms, List<Term> replacements) + { + return substitute(terms.toArray(new Term[0]), replacements.toArray(new Term[0])); } /** * @return the result of simultaneously replacing 'terms' by 'replacements' * in this term */ - public Term substitute(Term[] terms, Term[] replacements) { + public Term substitute(Term[] terms, Term[] replacements) + { long[] termPointers = new long[terms.length]; - for (int i = 0; i < termPointers.length; i++) { + for (int i = 0; i < termPointers.length; i++) + { termPointers[i] = terms[i].getPointer(); } long[] replacementPointers = new long[replacements.length]; - for (int i = 0; i < replacements.length; i++) { + for (int i = 0; i < replacements.length; i++) + { replacementPointers[i] = replacements[i].getPointer(); } @@ -167,13 +178,13 @@ public class Term return new Term(solver, termPointer); } - private native long substitute( - long pointer, long[] termPointers, long[] replacementPointers); + private native long substitute(long pointer, long[] termPointers, long[] replacementPointers); /** * @return true iff this term has an operator */ - public boolean hasOp() { + public boolean hasOp() + { return hasOp(pointer); } @@ -183,7 +194,8 @@ public class Term * @return the Op used to create this term * Note: This is safe to call when hasOp() returns true. */ - public Op getOp() { + public Op getOp() + { long opPointer = getOp(pointer); return new Op(solver, opPointer); } @@ -193,7 +205,8 @@ public class Term /** * @return true if this Term is a null term */ - public boolean isNull() { + public boolean isNull() + { return isNull(pointer); } @@ -205,7 +218,8 @@ public class Term * * @return the base value */ - public Term getConstArrayBase() { + public Term getConstArrayBase() + { long termPointer = getConstArrayBase(pointer); return new Term(solver, termPointer); } @@ -218,10 +232,12 @@ public class Term * * @return the elements of the constant sequence. */ - public Term[] getConstSequenceElements() { + public Term[] getConstSequenceElements() + { long[] termPointers = getConstSequenceElements(pointer); Term[] terms = new Term[termPointers.length]; - for (int i = 0; i < termPointers.length; i++) { + for (int i = 0; i < termPointers.length; i++) + { terms[i] = new Term(solver, termPointers[i]); } @@ -235,7 +251,8 @@ public class Term * * @return the Boolean negation of this term */ - public Term notTerm() { + public Term notTerm() + { long termPointer = notTerm(pointer); return new Term(solver, termPointer); } @@ -248,7 +265,8 @@ public class Term * @param t a Boolean term * @return the conjunction of this term and the given term */ - public Term andTerm(Term t) { + public Term andTerm(Term t) + { long termPointer = andTerm(pointer, t.getPointer()); return new Term(solver, termPointer); } @@ -261,7 +279,8 @@ public class Term * @param t a Boolean term * @return the disjunction of this term and the given term */ - public Term orTerm(Term t) { + public Term orTerm(Term t) + { long termPointer = orTerm(pointer, t.getPointer()); return new Term(solver, termPointer); } @@ -274,7 +293,8 @@ public class Term * @param t a Boolean term * @return the exclusive disjunction of this term and the given term */ - public Term xorTerm(Term t) { + public Term xorTerm(Term t) + { long termPointer = xorTerm(pointer, t.getPointer()); return new Term(solver, termPointer); } @@ -287,7 +307,8 @@ public class Term * @param t a Boolean term * @return the Boolean equivalence of this term and the given term */ - public Term eqTerm(Term t) { + public Term eqTerm(Term t) + { long termPointer = eqTerm(pointer, t.getPointer()); return new Term(solver, termPointer); } @@ -300,7 +321,8 @@ public class Term * @param t a Boolean term * @return the implication of this term and the given term */ - public Term impTerm(Term t) { + public Term impTerm(Term t) + { long termPointer = impTerm(pointer, t.getPointer()); return new Term(solver, termPointer); } @@ -314,9 +336,9 @@ public class Term * @param elseTerm the 'else' term * @return the if-then-else term with this term as the Boolean condition */ - public Term iteTerm(Term thenTerm, Term elseTerm) { - long termPointer = - iteTerm(pointer, thenTerm.getPointer(), elseTerm.getPointer()); + public Term iteTerm(Term thenTerm, Term elseTerm) + { + long termPointer = iteTerm(pointer, thenTerm.getPointer(), elseTerm.getPointer()); return new Term(solver, termPointer); } @@ -330,7 +352,8 @@ public class Term /** * @return true if the term is an integer that fits within a Java integer. */ - public boolean isInt() { + public boolean isInt() + { return isInt(pointer); } @@ -340,7 +363,8 @@ public class Term * @return the stored integer as an int. * Note: Asserts isInt(). */ - public int getInt() { + public int getInt() + { return getInt(pointer); } @@ -349,7 +373,8 @@ public class Term /** * @return true if the term is an integer that fits within a Java long. */ - public boolean isLong() { + public boolean isLong() + { return isLong(pointer); } @@ -359,7 +384,8 @@ public class Term * @return the stored integer as a long. * Note: Asserts isLong(). */ - public long getLong() { + public long getLong() + { return getLong(pointer); } @@ -368,7 +394,8 @@ public class Term /** * @return true if the term is an integer. */ - public boolean isInteger() { + public boolean isInteger() + { return isInteger(pointer); } @@ -378,7 +405,8 @@ public class Term * @return the stored integer in (decimal) string representation. * Note: Asserts isInteger(). */ - public String getInteger() { + public String getInteger() + { return getInteger(pointer); } @@ -387,7 +415,8 @@ public class Term /** * @return true if the term is a string constant. */ - public boolean isString() { + public boolean isString() + { return isString(pointer); } @@ -400,43 +429,73 @@ public class Term * term in some string representation, whatever data it may hold. * Asserts isString(). */ - public String getString() { + public String getString() + { return getString(pointer); } private native String getString(long pointer); - public class ConstIterator implements Iterator<Term> { + /** + * @return true if the term is a rational value. + */ + public boolean isRealValue() + { + return isRealValue(pointer); + } + + private native boolean isRealValue(long pointer); + + /** + * Asserts isRealValue(). + * @return the representation of a rational value as a pair of its numerator + * and denominator. + */ + public Pair<BigInteger, BigInteger> getRealValue() + { + String rational = getRealValue(pointer); + return Utils.getRational(rational); + } + + private native String getRealValue(long pointer); + + public class ConstIterator implements Iterator<Term> + { private int currentIndex; private int size; - public ConstIterator() { + public ConstIterator() + { currentIndex = -1; size = getNumChildren(); } - @Override - public boolean hasNext() { + @Override public boolean hasNext() + { return currentIndex < size - 1; } - @Override - public Term next() { - if (currentIndex >= size - 1) { + @Override public Term next() + { + if (currentIndex >= size - 1) + { throw new NoSuchElementException(); } currentIndex++; - try { + try + { return getChild(currentIndex); - } catch (CVC5ApiException e) { + } + catch (CVC5ApiException e) + { e.printStackTrace(); throw new RuntimeException(e.getMessage()); } } } - @Override - public Iterator<Term> iterator() { + @Override public Iterator<Term> iterator() + { return new ConstIterator(); } } diff --git a/src/api/java/cvc5/Utils.java b/src/api/java/cvc5/Utils.java index 7f32932e4..077b77168 100644 --- a/src/api/java/cvc5/Utils.java +++ b/src/api/java/cvc5/Utils.java @@ -1,4 +1,3 @@ - /****************************************************************************** * Top contributors (to current version): * Mudathir Mohamed @@ -17,8 +16,11 @@ package cvc5; import java.io.IOException; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; -class Utils +public class Utils { static { @@ -32,4 +34,180 @@ class Utils { System.loadLibrary("cvc5jni"); } + + /** + * return sorts array from array of pointers + */ + public static Sort[] getSorts(Solver solver, long[] pointers) + { + Sort[] sorts = new Sort[pointers.length]; + for (int i = 0; i < pointers.length; i++) + { + sorts[i] = new Sort(solver, pointers[i]); + } + return sorts; + } + + /** + * return terms array from array of pointers + */ + public static Term[] getTerms(Solver solver, long[] pointers) + { + Term[] terms = new Term[pointers.length]; + for (int i = 0; i < pointers.length; i++) + { + terms[i] = new Term(solver, pointers[i]); + } + return terms; + } + + /** + * get pointers from one dimensional array + */ + public static long[] getPointers(IPointer[] objects) + { + long[] pointers = new long[objects.length]; + for (int i = 0; i < pointers.length; i++) + { + pointers[i] = objects[i].getPointer(); + } + return pointers; + } + + /** + * get pointers from two dimensional matrix + */ + public static long[][] getPointers(IPointer[][] objects) + { + long[][] pointers = new long[objects.length][]; + for (int i = 0; i < pointers.length; i++) + { + pointers[i] = new long[objects[i].length]; + for (int j = 0; j < objects[i].length; j++) + { + pointers[i][j] = objects[i][j].getPointer(); + } + } + return pointers; + } + + public static void validateUnsigned(int integer, String name) throws CVC5ApiException + { + if (integer < 0) + { + throw new CVC5ApiException("Expected " + name + " '" + integer + "' to be non negative."); + } + } + + public static void validateUnsigned(long integer, String name) throws CVC5ApiException + { + if (integer < 0) + { + throw new CVC5ApiException("Expected " + name + " '" + integer + "' to be non negative."); + } + } + + public static void validateUnsigned(int[] integers, String name) throws CVC5ApiException + { + for (int i = 0; i < integers.length; i++) + { + if (integers[i] < 0) + { + throw new CVC5ApiException( + "Expected " + name + "[" + i + "] '" + integers[i] + "' to be non negative."); + } + } + } + + public static void validateUnsigned(long[] integers, String name) throws CVC5ApiException + { + for (int i = 0; i < integers.length; i++) + { + if (integers[i] < 0) + { + throw new CVC5ApiException( + "Expected " + name + "[" + i + "] '" + integers[i] + "' to be non negative."); + } + } + } + + public static <K> Pair<K, Long>[] getPairs(Pair<K, ? extends AbstractPointer>[] abstractPointers) + { + Pair<K, Long>[] pointers = new Pair[abstractPointers.length]; + for (int i = 0; i < pointers.length; i++) + { + pointers[i] = new Pair<>(abstractPointers[i].first, abstractPointers[i].second.getPointer()); + } + return pointers; + } + + /** + Convert a rational string a/b to a pair of BigIntegers + */ + public static Pair<BigInteger, BigInteger> getRational(String rational) + { + if (rational.contains("/")) + { + String[] pair = rational.split("/"); + return new Pair<>(new BigInteger(pair[0]), new BigInteger(pair[1])); + } + return new Pair<>(new BigInteger(rational), new BigInteger("1")); + } + + /** + * Get the string version of define-fun command. + * @param f the function to print + * @param params the function parameters + * @param body the function body + * @return a string version of define-fun + */ + private static String defineFunToString(Term f, Term[] params, Term body) + { + Sort sort = f.getSort(); + if (sort.isFunction()) + { + sort = sort.getFunctionCodomainSort(); + } + StringBuilder ss = new StringBuilder(); + ss.append("(define-fun ").append(f).append(" ("); + for (int i = 0; i < params.length; ++i) + { + if (i > 0) + { + ss.append(' '); + } + ss.append('(').append(params[i]).append(' ').append(params[i].getSort()).append(')'); + } + ss.append(") ").append(sort).append(' ').append(body).append(')'); + return ss.toString(); + } + + /** + * Print solutions for synthesis conjecture to the standard output stream. + * @param terms the terms for which the synthesis solutions were retrieved + * @param sols the synthesis solutions of the given terms + */ + public static void printSynthSolutions(Term[] terms, Term[] sols) throws CVC5ApiException + { + System.out.println('('); + + for (int i = 0; i < terms.length; ++i) + { + List<Term> params = new ArrayList<>(); + Term body = null; + if (sols[i].getKind() == Kind.LAMBDA) + { + for (Term t : sols[i].getChild(0)) + { + params.add(t); + } + body = sols[i].getChild(1); + } + if (body != null) + { + System.out.println(" " + defineFunToString(terms[i], params.toArray(new Term[0]), body)); + } + } + System.out.println(')'); + } } diff --git a/src/api/java/jni/cvc5JavaApi.h b/src/api/java/jni/cvc5JavaApi.h index 2aa860f40..fc4399fed 100644 --- a/src/api/java/jni/cvc5JavaApi.h +++ b/src/api/java/jni/cvc5JavaApi.h @@ -13,6 +13,8 @@ * The cvc5 Java API. */ +#include <jni.h> + #ifndef CVC5__JAVA_API_H #define CVC5__JAVA_API_H @@ -36,3 +38,49 @@ CVC5_JAVA_API_TRY_CATCH_END(env) \ return returnValue; #endif // CVC5__JAVA_API_H + +/** + * Convert pointers coming from Java to cvc5 objects + * @tparam T cvc5 class (Term, Sort, Grammar, etc) + * @param env jni environment + * @param jPointers pointers coming from java + * @return a vector of cvc5 objects + */ +template <class T> +std::vector<T> getObjectsFromPointers(JNIEnv* env, jlongArray jPointers) +{ + // get the size of pointers + jsize size = env->GetArrayLength(jPointers); + // allocate a buffer for c pointers + std::vector<jlong> cPointers(size); + // copy java array to the buffer + env->GetLongArrayRegion(jPointers, 0, size, cPointers.data()); + // copy the terms into a vector + std::vector<T> objects; + for (jlong pointer : cPointers) + { + T* term = reinterpret_cast<T*>(pointer); + objects.push_back(*term); + } + return objects; +} + +/** + * Convert cvc5 objects into pointers + * @tparam T cvc5 class (Term, Sort, Grammar, etc) + * @param env jni environment + * @param objects cvc5 objects + * @return jni array of pointers + */ +template <class T> +jlongArray getPointersFromObjects(JNIEnv* env, std::vector<T> objects) +{ + std::vector<jlong> pointers(objects.size()); + for (size_t i = 0; i < objects.size(); i++) + { + pointers[i] = reinterpret_cast<jlong>(new T(objects[i])); + } + jlongArray ret = env->NewLongArray(objects.size()); + env->SetLongArrayRegion(ret, 0, objects.size(), pointers.data()); + return ret; +}
\ No newline at end of file diff --git a/src/api/java/jni/cvc5_Solver.cpp b/src/api/java/jni/cvc5_Solver.cpp index 9d7690e59..9bcecd07f 100644 --- a/src/api/java/jni/cvc5_Solver.cpp +++ b/src/api/java/jni/cvc5_Solver.cpp @@ -28,7 +28,7 @@ using namespace cvc5::api; JNIEXPORT jlong JNICALL Java_cvc5_Solver_newSolver(JNIEnv*, jobject) { Solver* solver = new Solver(); - return ((jlong)solver); + return reinterpret_cast<jlong>(solver); } /* @@ -37,27 +37,2542 @@ JNIEXPORT jlong JNICALL Java_cvc5_Solver_newSolver(JNIEnv*, jobject) * Signature: (J)V */ JNIEXPORT void JNICALL Java_cvc5_Solver_deletePointer(JNIEnv*, - jclass, + jclass, + jlong pointer) +{ + delete (reinterpret_cast<Solver*>(pointer)); +} + +/* + * Class: cvc5_Solver + * Method: getNullSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getNullSort(JNIEnv* env, + jobject, jlong pointer) { - delete ((Solver*)pointer); + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getNullSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getBooleanSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getBooleanSort(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getBooleanSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getIntegerSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getIntegerSort(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getIntegerSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getRealSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getRealSort(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getRealSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getRegExpSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getRegExpSort(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getRegExpSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getRoundingModeSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getRoundingModeSort(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getRoundingModeSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getStringSort + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getStringSort(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->getStringSort()); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkArraySort + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkArraySort(JNIEnv* env, + jobject, + jlong pointer, + jlong indexSortPointer, + jlong elementSortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* indexSort = reinterpret_cast<Sort*>(indexSortPointer); + Sort* elementSort = reinterpret_cast<Sort*>(elementSortPointer); + Sort* retPointer = new Sort(solver->mkArraySort(*indexSort, *elementSort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkBitVectorSort + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkBitVectorSort(JNIEnv* env, + jobject, + jlong pointer, + jint size) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = new Sort(solver->mkBitVectorSort((uint32_t)size)); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkFloatingPointSort + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkFloatingPointSort( + JNIEnv* env, jobject, jlong pointer, jint exp, jint sig) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sortPointer = + new Sort(solver->mkFloatingPointSort((uint32_t)exp, (uint32_t)sig)); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeSort + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkDatatypeSort( + JNIEnv* env, jobject, jlong pointer, jlong datatypeDeclPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + DatatypeDecl* decl = reinterpret_cast<DatatypeDecl*>(datatypeDeclPointer); + Sort* retPointer = new Sort(solver->mkDatatypeSort(*decl)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeSorts + * Signature: (J[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_cvc5_Solver_mkDatatypeSorts__J_3J( + JNIEnv* env, jobject, jlong pointer, jlongArray jDecls) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<DatatypeDecl> decls = + getObjectsFromPointers<DatatypeDecl>(env, jDecls); + std::vector<Sort> sorts = solver->mkDatatypeSorts(decls); + std::vector<jlong> sortPointers(sorts.size()); + + for (size_t i = 0; i < sorts.size(); i++) + { + sortPointers[i] = reinterpret_cast<jlong>(new Sort(sorts[i])); + } + + jlongArray ret = env->NewLongArray(sorts.size()); + env->SetLongArrayRegion(ret, 0, sorts.size(), sortPointers.data()); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, nullptr); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeSorts + * Signature: (J[J[J)[J + */ +JNIEXPORT jlongArray JNICALL +Java_cvc5_Solver_mkDatatypeSorts__J_3J_3J(JNIEnv* env, + jobject, + jlong pointer, + jlongArray jDecls, + jlongArray jUnresolved) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<DatatypeDecl> decls = + getObjectsFromPointers<DatatypeDecl>(env, jDecls); + std::vector<Sort> cUnresolved = + getObjectsFromPointers<Sort>(env, jUnresolved); + std::set<Sort> unresolved(cUnresolved.begin(), cUnresolved.end()); + std::vector<Sort> sorts = solver->mkDatatypeSorts(decls, unresolved); + jlongArray ret = getPointersFromObjects<Sort>(env, sorts); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, nullptr); +} + +/* + * Class: cvc5_Solver + * Method: mkFunctionSort + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkFunctionSort__JJJ(JNIEnv* env, + jobject, + jlong pointer, + jlong domainPointer, + jlong codomainPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* domain = reinterpret_cast<Sort*>(domainPointer); + Sort* codomain = reinterpret_cast<Sort*>(codomainPointer); + Sort* sortPointer = new Sort(solver->mkFunctionSort(*domain, *codomain)); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkFunctionSort + * Signature: (J[JJ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkFunctionSort__J_3JJ(JNIEnv* env, + jobject, + jlong pointer, + jlongArray sortPointers, + jlong codomainPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* codomain = reinterpret_cast<Sort*>(codomainPointer); + std::vector<Sort> sorts = getObjectsFromPointers<Sort>(env, sortPointers); + Sort* retPointer = new Sort(solver->mkFunctionSort(sorts, *codomain)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkParamSort + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkParamSort(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + Sort* retPointer = new Sort(solver->mkParamSort(cSymbol)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkPredicateSort + * Signature: (J[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkPredicateSort( + JNIEnv* env, jobject, jlong pointer, jlongArray sortPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Sort> sorts = getObjectsFromPointers<Sort>(env, sortPointers); + Sort* retPointer = new Sort(solver->mkPredicateSort(sorts)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkRecordSort + * Signature: (J[Lcvc5/Pair;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkRecordSort(JNIEnv* env, + jobject, + jlong pointer, + jobjectArray jFields) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + jsize size = env->GetArrayLength(jFields); + // Lcvc5/Pair; is signature of cvc5.Pair<String, Long> + jclass pairClass = env->FindClass("Lcvc5/Pair;"); + jclass longClass = env->FindClass("Ljava/lang/Long;"); + // Ljava/lang/Object; is the signature of cvc5.Pair.first field + jfieldID firstFieldId = + env->GetFieldID(pairClass, "first", "Ljava/lang/Object;"); + // Ljava/lang/Object; is the signature of cvc5.Pair.second field + jfieldID secondFieldId = + env->GetFieldID(pairClass, "second", "Ljava/lang/Object;"); + // we need to call method longValue to get long Long object + jmethodID methodId = env->GetMethodID(longClass, "longValue", "()J"); + + std::vector<std::pair<std::string, Sort>> cFields; + for (jsize i = 0; i < size; i++) + { + // get the pair at index i + jobject object = env->GetObjectArrayElement(jFields, i); + + // get the object at cvc5.Pair.first and convert it to char * + jstring jFirst = (jstring)env->GetObjectField(object, firstFieldId); + const char* cFirst = env->GetStringUTFChars(jFirst, nullptr); + + // get the object at cvc5.Pair.second and convert it to Sort + jobject jSecond = env->GetObjectField(object, secondFieldId); + jlong sortPointer = env->CallLongMethod(jSecond, methodId); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + + // add the pair to to the list of fields + cFields.push_back(std::make_pair(std::string(cFirst), *sort)); + } + // get the record sort from the solver + Sort* retPointer = new Sort(solver->mkRecordSort(cFields)); + // return a pointer to the sort + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkSetSort + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkSetSort(JNIEnv* env, + jobject, + jlong pointer, + jlong elemSortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* elemSort = reinterpret_cast<Sort*>(elemSortPointer); + Sort* retPointer = new Sort(solver->mkSetSort(*elemSort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkBagSort + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkBagSort(JNIEnv* env, + jobject, + jlong pointer, + jlong elemSortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* elemSort = reinterpret_cast<Sort*>(elemSortPointer); + Sort* retPointer = new Sort(solver->mkBagSort(*elemSort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkSequenceSort + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkSequenceSort(JNIEnv* env, + jobject, + jlong pointer, + jlong elemSortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* elemSort = reinterpret_cast<Sort*>(elemSortPointer); + Sort* sortPointer = new Sort(solver->mkSequenceSort(*elemSort)); + return reinterpret_cast<jlong>(sortPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkUninterpretedSort + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkUninterpretedSort(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* cSymbol = env->GetStringUTFChars(jSymbol, nullptr); + Sort* sort = new Sort(solver->mkUninterpretedSort(std::string(cSymbol))); + env->ReleaseStringUTFChars(jSymbol, cSymbol); + return reinterpret_cast<jlong>(sort); + + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkSortConstructorSort + * Signature: (JLjava/lang/String;I)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkSortConstructorSort( + JNIEnv* env, jobject, jlong pointer, jstring jSymbol, jint arity) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + Sort* retPointer = + new Sort(solver->mkSortConstructorSort(cSymbol, (size_t)arity)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTupleSort + * Signature: (J[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTupleSort(JNIEnv* env, + jobject, + jlong pointer, + jlongArray sortPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Sort> sorts = getObjectsFromPointers<Sort>(env, sortPointers); + Sort* retPointer = new Sort(solver->mkTupleSort(sorts)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JI(JNIEnv* env, + jobject, + jlong pointer, + jint kindValue) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Term* retPointer = new Term(solver->mkTerm(kind)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JIJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JIJ( + JNIEnv* env, jobject, jlong pointer, jint kindValue, jlong childPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Term* child = reinterpret_cast<Term*>(childPointer); + Term* termPointer = new Term(solver->mkTerm(kind, *child)); + return reinterpret_cast<jlong>(termPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JIJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JIJJ(JNIEnv* env, + jobject, + jlong pointer, + jint kindValue, + jlong child1Pointer, + jlong child2Pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Term* child1 = reinterpret_cast<Term*>(child1Pointer); + Term* child2 = reinterpret_cast<Term*>(child2Pointer); + Term* termPointer = new Term(solver->mkTerm(kind, *child1, *child2)); + return reinterpret_cast<jlong>(termPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JIJJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JIJJJ(JNIEnv* env, + jobject, + jlong pointer, + jint kindValue, + jlong child1Pointer, + jlong child2Pointer, + jlong child3Pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Term* child1 = reinterpret_cast<Term*>(child1Pointer); + Term* child2 = reinterpret_cast<Term*>(child2Pointer); + Term* child3 = reinterpret_cast<Term*>(child3Pointer); + Term* retPointer = new Term(solver->mkTerm(kind, *child1, *child2, *child3)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JI[J)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkTerm__JI_3J(JNIEnv* env, + jobject, + jlong pointer, + jint kindValue, + jlongArray childrenPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + std::vector<Term> children = + getObjectsFromPointers<Term>(env, childrenPointers); + Term* retPointer = new Term(solver->mkTerm(kind, children)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JJ(JNIEnv* env, + jobject, + jlong pointer, + jlong opPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Op* op = reinterpret_cast<Op*>(opPointer); + Term* retPointer = new Term(solver->mkTerm(*op)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JJJ( + JNIEnv* env, jobject, jlong pointer, jlong opPointer, jlong childPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Op* op = reinterpret_cast<Op*>(opPointer); + Term* child = reinterpret_cast<Term*>(childPointer); + Term* retPointer = new Term(solver->mkTerm(*op, *child)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JJJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JJJJ(JNIEnv* env, + jobject, + jlong pointer, + jlong opPointer, + jlong child1Pointer, + jlong child2Pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Op* op = reinterpret_cast<Op*>(opPointer); + Term* child1 = reinterpret_cast<Term*>(child1Pointer); + Term* child2 = reinterpret_cast<Term*>(child2Pointer); + Term* retPointer = new Term(solver->mkTerm(*op, *child1, *child2)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JJJJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTerm__JJJJJ(JNIEnv* env, + jobject, + jlong pointer, + jlong opPointer, + jlong child1Pointer, + jlong child2Pointer, + jlong child3Pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Op* op = reinterpret_cast<Op*>(opPointer); + Term* child1 = reinterpret_cast<Term*>(child1Pointer); + Term* child2 = reinterpret_cast<Term*>(child2Pointer); + Term* child3 = reinterpret_cast<Term*>(child3Pointer); + Term* retPointer = new Term(solver->mkTerm(*op, *child1, *child2, *child3)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTerm + * Signature: (JJ[J)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkTerm__JJ_3J(JNIEnv* env, + jobject, + jlong pointer, + jlong opPointer, + jlongArray childrenPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Op* op = reinterpret_cast<Op*>(opPointer); + std::vector<Term> children = + getObjectsFromPointers<Term>(env, childrenPointers); + Term* retPointer = new Term(solver->mkTerm(*op, children)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTuple + * Signature: (J[J[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTuple(JNIEnv* env, + jobject, + jlong pointer, + jlongArray sortPointers, + jlongArray termPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Sort> sorts = getObjectsFromPointers<Sort>(env, sortPointers); + std::vector<Term> terms = getObjectsFromPointers<Term>(env, termPointers); + Term* retPointer = new Term(solver->mkTuple(sorts, terms)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkOp + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkOp__JI(JNIEnv* env, + jobject, + jlong pointer, + jint kindValue) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Op* retPointer = new Op(solver->mkOp(kind)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkOp + * Signature: (JILjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkOp__JILjava_lang_String_2( + JNIEnv* env, jobject, jlong pointer, jint kindValue, jstring jArg) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + const char* s = env->GetStringUTFChars(jArg, nullptr); + std::string cArg(s); + + Op* retPointer = new Op(solver->mkOp(kind, cArg)); + + env->ReleaseStringUTFChars(jArg, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkOp + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkOp__JII( + JNIEnv* env, jobject, jlong pointer, jint kindValue, jint arg) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Op* retPointer = new Op(solver->mkOp(kind, (uint32_t)arg)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkOp + * Signature: (JIII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkOp__JIII( + JNIEnv* env, jobject, jlong pointer, jint kindValue, jint arg1, jint arg2) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + Op* retPointer = new Op(solver->mkOp(kind, (uint32_t)arg1, (uint32_t)arg2)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkOp + * Signature: (JI[I)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkOp__JI_3I( + JNIEnv* env, jobject, jlong pointer, jint kindValue, jintArray jArgs) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Kind kind = (Kind)kindValue; + + jsize size = env->GetArrayLength(jArgs); + jint* argElements = env->GetIntArrayElements(jArgs, nullptr); + + std::vector<uint32_t> cArgs(size); + for (jsize i = 0; i < size; i++) + { + cArgs[i] = (uint32_t)argElements[i]; + } + env->ReleaseIntArrayElements(jArgs, argElements, 0); + + Op* retPointer = new Op(solver->mkOp(kind, cArgs)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkTrue + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkTrue(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* termPointer = new Term(solver->mkTrue()); + return reinterpret_cast<jlong>(termPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkFalse + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkFalse(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* termPointer = new Term(solver->mkFalse()); + return reinterpret_cast<jlong>(termPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkBoolean + * Signature: (JZ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkBoolean(JNIEnv* env, + jobject, + jlong pointer, + jboolean val) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkBoolean((bool)val)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkPi + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkPi(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkPi()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkInteger + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkInteger__JLjava_lang_String_2( + JNIEnv* env, jobject, jlong pointer, jstring jS) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jS, nullptr); + std::string cS(s); + Term* retPointer = new Term(solver->mkInteger(cS)); + env->ReleaseStringUTFChars(jS, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkInteger + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkInteger__JJ(JNIEnv* env, + jobject, + jlong pointer, + jlong val) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* termPointer = new Term(solver->mkInteger((int64_t)val)); + return reinterpret_cast<jlong>(termPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkReal + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkReal__JLjava_lang_String_2( + JNIEnv* env, jobject, jlong pointer, jstring jS) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jS, nullptr); + std::string cS(s); + Term* retPointer = new Term(solver->mkReal(cS)); + env->ReleaseStringUTFChars(jS, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkRealValue + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkRealValue(JNIEnv* env, + jobject, + jlong pointer, + jlong val) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkReal((int64_t)val)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkReal + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkReal__JJJ( + JNIEnv* env, jobject, jlong pointer, jlong num, jlong den) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkReal((int64_t)num, (int64_t)den)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkRegexpEmpty + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkRegexpEmpty(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkRegexpEmpty()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkRegexpSigma + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkRegexpSigma(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkRegexpSigma()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkEmptySet + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkEmptySet(JNIEnv* env, + jobject, + jlong pointer, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->mkEmptySet(*sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkEmptyBag + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkEmptyBag(JNIEnv* env, + jobject, + jlong pointer, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->mkEmptyBag(*sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkSepNil + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkSepNil(JNIEnv* env, + jobject, + jlong pointer, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->mkSepNil(*sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkString + * Signature: (JLjava/lang/String;Z)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkString__JLjava_lang_String_2Z( + JNIEnv* env, jobject, jlong pointer, jstring jS, jboolean useEscSequences) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jS, nullptr); + std::string cS(s); + Term* retPointer = new Term(solver->mkString(cS, (bool)useEscSequences)); + env->ReleaseStringUTFChars(jS, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkEmptySequence + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkEmptySequence(JNIEnv* env, + jobject, + jlong pointer, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->mkEmptySequence(*sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkUniverseSet + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkUniverseSet(JNIEnv* env, + jobject, + jlong pointer, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->mkUniverseSet(*sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkBitVector + * Signature: (JIJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkBitVector__JIJ( + JNIEnv* env, jobject, jlong pointer, jint size, jlong val) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = + new Term(solver->mkBitVector((uint32_t)size, (uint64_t)val)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkBitVector + * Signature: (JILjava/lang/String;I)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkBitVector__JILjava_lang_String_2I( + JNIEnv* env, jobject, jlong pointer, jint size, jstring jS, jint base) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jS, nullptr); + std::string cS(s); + Term* retPointer = + new Term(solver->mkBitVector((uint32_t)size, cS, (uint32_t)base)); + env->ReleaseStringUTFChars(jS, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkConstArray + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkConstArray( + JNIEnv* env, jobject, jlong pointer, jlong sortPointer, jlong valPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* val = reinterpret_cast<Term*>(valPointer); + Term* retPointer = new Term(solver->mkConstArray(*sort, *val)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkPosInf + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkPosInf( + JNIEnv* env, jobject, jlong pointer, jint exp, jint sig) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkPosInf((uint32_t)exp, (uint32_t)sig)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkNegInf + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkNegInf( + JNIEnv* env, jobject, jlong pointer, jint exp, jint sig) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkNegInf((uint32_t)exp, (uint32_t)sig)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkNaN + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkNaN(JNIEnv* env, jobject, jlong pointer, jint exp, jint sig) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkNaN((uint32_t)exp, (uint32_t)sig)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkPosZero + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkPosZero( + JNIEnv* env, jobject, jlong pointer, jint exp, jint sig) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkPosZero((uint32_t)exp, (uint32_t)sig)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkNegZero + * Signature: (JII)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkNegZero( + JNIEnv* env, jobject, jlong pointer, jint exp, jint sig) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkNegZero((uint32_t)exp, (uint32_t)sig)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkRoundingMode + * Signature: (JI)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkRoundingMode(JNIEnv* env, + jobject, + jlong pointer, + jint rm) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkRoundingMode((RoundingMode)rm)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkUninterpretedConst + * Signature: (JJI)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkUninterpretedConst( + JNIEnv* env, jobject, jlong pointer, jlong sortPointer, jint index) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = + new Term(solver->mkUninterpretedConst(*sort, (int32_t)index)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkAbstractValue + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkAbstractValue__JLjava_lang_String_2( + JNIEnv* env, jobject, jlong pointer, jstring jIndex) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jIndex, nullptr); + std::string cIndex(s); + Term* retPointer = new Term(solver->mkAbstractValue(cIndex)); + env->ReleaseStringUTFChars(jIndex, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkAbstractValue + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkAbstractValue__JJ(JNIEnv* env, + jobject, + jlong pointer, + jlong index) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->mkAbstractValue((uint64_t)index)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkFloatingPoint + * Signature: (JIIJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkFloatingPoint( + JNIEnv* env, jobject, jlong pointer, jint exp, jint sig, jlong valPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* val = reinterpret_cast<Term*>(valPointer); + Term* retPointer = + new Term(solver->mkFloatingPoint((uint32_t)exp, (uint32_t)sig, *val)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkConst + * Signature: (JJLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkConst__JJLjava_lang_String_2( + JNIEnv* env, jobject, jlong pointer, jlong sortPointer, jstring jSymbol) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + Term* retPointer = new Term(solver->mkConst(*sort, cSymbol)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkConst + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkConst__JJ(JNIEnv* env, + jobject, + jlong pointer, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->mkConst(*sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkVar + * Signature: (JJLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkVar( + JNIEnv* env, jobject, jlong pointer, jlong sortPointer, jstring jSymbol) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + Term* ret = new Term(solver->mkVar(*sort, cSymbol)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(ret); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeConstructorDecl + * Signature: (JLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkDatatypeConstructorDecl( + JNIEnv* env, jobject, jlong pointer, jstring jName) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jName, nullptr); + std::string cName(s); + + DatatypeConstructorDecl* retPointer = + new DatatypeConstructorDecl(solver->mkDatatypeConstructorDecl(cName)); + env->ReleaseStringUTFChars(jName, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeDecl + * Signature: (JLjava/lang/String;Z)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkDatatypeDecl__JLjava_lang_String_2Z( + JNIEnv* env, jobject, jlong pointer, jstring jName, jboolean isCoDatatype) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jName, nullptr); + std::string cName(s); + DatatypeDecl* retPointer = + new DatatypeDecl(solver->mkDatatypeDecl(cName, (bool)isCoDatatype)); + env->ReleaseStringUTFChars(jName, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeDecl + * Signature: (JLjava/lang/String;JZ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkDatatypeDecl__JLjava_lang_String_2JZ(JNIEnv* env, + jobject, + jlong pointer, + jstring jName, + jlong paramPointer, + jboolean isCoDatatype) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jName, nullptr); + std::string cName(s); + Sort* param = reinterpret_cast<Sort*>(paramPointer); + DatatypeDecl* retPointer = new DatatypeDecl( + solver->mkDatatypeDecl(cName, *param, (bool)isCoDatatype)); + env->ReleaseStringUTFChars(jName, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkDatatypeDecl + * Signature: (JLjava/lang/String;[JZ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_mkDatatypeDecl__JLjava_lang_String_2_3JZ(JNIEnv* env, + jobject, + jlong pointer, + jstring jName, + jlongArray jParams, + jboolean isCoDatatype) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jName, nullptr); + std::string cName(s); + std::vector<Sort> params = getObjectsFromPointers<Sort>(env, jParams); + DatatypeDecl* retPointer = new DatatypeDecl( + solver->mkDatatypeDecl(cName, params, (bool)isCoDatatype)); + env->ReleaseStringUTFChars(jName, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: simplify + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_simplify(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + Term* retPointer = new Term(solver->simplify(*term)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: assertFormula + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_assertFormula(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + solver->assertFormula(*term); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: checkSat + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_checkSat(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Result* retPointer = new Result(solver->checkSat()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: checkSatAssuming + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_checkSatAssuming__JJ( + JNIEnv* env, jobject, jlong pointer, jlong assumptionPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* assumption = reinterpret_cast<Term*>(assumptionPointer); + Result* retPointer = new Result(solver->checkSatAssuming(*assumption)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: checkSatAssuming + * Signature: (J[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_checkSatAssuming__J_3J( + JNIEnv* env, jobject, jlong pointer, jlongArray jAssumptions) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> assumptions = + getObjectsFromPointers<Term>(env, jAssumptions); + Result* retPointer = new Result(solver->checkSatAssuming(assumptions)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: checkEntailed + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_checkEntailed__JJ(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + Result* retPointer = new Result(solver->checkEntailed(*term)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: checkEntailed + * Signature: (J[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_checkEntailed__J_3J(JNIEnv* env, + jobject, + jlong pointer, + jlongArray jTerms) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> terms = getObjectsFromPointers<Term>(env, jTerms); + Result* retPointer = new Result(solver->checkEntailed(terms)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: declareDatatype + * Signature: (JLjava/lang/String;[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_declareDatatype( + JNIEnv* env, jobject, jlong pointer, jstring jSymbol, jlongArray jCtors) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<DatatypeConstructorDecl> ctors = + getObjectsFromPointers<DatatypeConstructorDecl>(env, jCtors); + Sort* retPointer = new Sort(solver->declareDatatype(cSymbol, ctors)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: declareFun + * Signature: (JLjava/lang/String;[JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_declareFun(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol, + jlongArray jSorts, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Sort> sorts = getObjectsFromPointers<Sort>(env, jSorts); + Term* retPointer = new Term(solver->declareFun(cSymbol, sorts, *sort)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: declareSort + * Signature: (JLjava/lang/String;I)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_declareSort( + JNIEnv* env, jobject, jlong pointer, jstring jSymbol, jint arity) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + Sort* retPointer = new Sort(solver->declareSort(cSymbol, (uint32_t)arity)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: defineFun + * Signature: (JLjava/lang/String;[JJJZ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_defineFun__JLjava_lang_String_2_3JJJZ(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol, + jlongArray jVars, + jlong sortPointer, + jlong termPointer, + jboolean global) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* term = reinterpret_cast<Term*>(termPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = + new Term(solver->defineFun(cSymbol, vars, *sort, *term, (bool)global)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: defineFun + * Signature: (JJ[JJZ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_defineFun__JJ_3JJZ(JNIEnv* env, + jobject, + jlong pointer, + jlong funPointer, + jlongArray jVars, + jlong termPointer, + jboolean global) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* fun = reinterpret_cast<Term*>(funPointer); + Term* term = reinterpret_cast<Term*>(termPointer); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = + new Term(solver->defineFun(*fun, vars, *term, (bool)global)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: defineFunRec + * Signature: (JLjava/lang/String;[JJJZ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_defineFunRec__JLjava_lang_String_2_3JJJZ(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol, + jlongArray jVars, + jlong sortPointer, + jlong termPointer, + jboolean global) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* term = reinterpret_cast<Term*>(termPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = + new Term(solver->defineFunRec(cSymbol, vars, *sort, *term, (bool)global)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: defineFunRec + * Signature: (JJ[JJZ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_defineFunRec__JJ_3JJZ(JNIEnv* env, + jobject, + jlong pointer, + jlong funPointer, + jlongArray jVars, + jlong termPointer, + jboolean global) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* fun = reinterpret_cast<Term*>(funPointer); + Term* term = reinterpret_cast<Term*>(termPointer); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = + new Term(solver->defineFunRec(*fun, vars, *term, (bool)global)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: defineFunsRec + * Signature: (J[J[[J[JZ)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_defineFunsRec(JNIEnv* env, + jobject, + jlong pointer, + jlongArray jFuns, + jobjectArray jVars, + jlongArray jTerms, + jboolean global) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> funs = getObjectsFromPointers<Term>(env, jFuns); + std::vector<Term> terms = getObjectsFromPointers<Term>(env, jTerms); + std::vector<std::vector<Term>> varsMatrix; + jsize rows = env->GetArrayLength(jVars); + for (jint i = 0; i < rows; i++) + { + std::vector<Term> vars; + jlongArray row = (jlongArray)env->GetObjectArrayElement(jVars, i); + jsize columns = env->GetArrayLength(row); + jlong* columnElements = env->GetLongArrayElements(row, nullptr); + for (jint j = 0; j < columns; j++) + { + Term* var = reinterpret_cast<Term*>((jlongArray)columnElements[j]); + vars.push_back(*var); + } + varsMatrix.push_back(vars); + } + solver->defineFunsRec(funs, varsMatrix, terms, (bool)global); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: getAssertions + * Signature: (J)[J + */ +JNIEXPORT jlongArray JNICALL Java_cvc5_Solver_getAssertions(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> assertions = solver->getAssertions(); + jlongArray ret = getPointersFromObjects<Term>(env, assertions); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, nullptr); +} + +/* + * Class: cvc5_Solver + * Method: getInfo + * Signature: (JLjava/lang/String;)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_cvc5_Solver_getInfo(JNIEnv* env, + jobject, + jlong pointer, + jstring jFlag) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jFlag, nullptr); + std::string cFlag(s); + env->ReleaseStringUTFChars(jFlag, s); + return env->NewStringUTF(solver->getInfo(cFlag).c_str()); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getOption + * Signature: (JLjava/lang/String;)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_cvc5_Solver_getOption(JNIEnv* env, + jobject, + jlong pointer, + jstring jOption) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jOption, nullptr); + std::string cOption(s); + env->ReleaseStringUTFChars(jOption, s); + return env->NewStringUTF(solver->getOption(cOption).c_str()); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getUnsatAssumptions + * Signature: (J)[J + */ +JNIEXPORT jlongArray JNICALL Java_cvc5_Solver_getUnsatAssumptions(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> core = solver->getUnsatAssumptions(); + jlongArray ret = getPointersFromObjects<Term>(env, core); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, nullptr); +} + +/* + * Class: cvc5_Solver + * Method: getUnsatCore + * Signature: (J)[J + */ +JNIEXPORT jlongArray JNICALL Java_cvc5_Solver_getUnsatCore(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> core = solver->getUnsatCore(); + jlongArray ret = getPointersFromObjects<Term>(env, core); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, nullptr); +} + +/* + * Class: cvc5_Solver + * Method: getValue + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getValue__JJ(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + Term* retPointer = new Term(solver->getValue(*term)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getValue + * Signature: (J[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_cvc5_Solver_getValue__J_3J( + JNIEnv* env, jobject, jlong pointer, jlongArray termPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> terms = getObjectsFromPointers<Term>(env, termPointers); + std::vector<Term> values = solver->getValue(terms); + jlongArray ret = getPointersFromObjects<Term>(env, values); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: isModelCoreSymbol + * Signature: (JJ)Z + */ +JNIEXPORT jboolean JNICALL Java_cvc5_Solver_isModelCoreSymbol(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + return static_cast<jboolean>(solver->isModelCoreSymbol(*term)); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, static_cast<jboolean>(false)); +} + +/* + * Class: cvc5_Solver + * Method: getModel + * Signature: (J[J[J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_cvc5_Solver_getModel(JNIEnv* env, + jobject, + jlong pointer, + jlongArray sortPointers, + jlongArray varPointers) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Sort> sorts = getObjectsFromPointers<Sort>(env, sortPointers); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, varPointers); + std::string model = solver->getModel(sorts, vars); + return env->NewStringUTF(model.c_str()); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getQuantifierElimination + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getQuantifierElimination( + JNIEnv* env, jobject, jlong pointer, jlong qPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* q = reinterpret_cast<Term*>(qPointer); + Term* retPointer = new Term(solver->getQuantifierElimination(*q)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getQuantifierEliminationDisjunct + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getQuantifierEliminationDisjunct( + JNIEnv* env, jobject, jlong pointer, jlong qPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* q = reinterpret_cast<Term*>(qPointer); + Term* retPointer = new Term(solver->getQuantifierEliminationDisjunct(*q)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: declareSeparationHeap + * Signature: (JJJ)V + */ +JNIEXPORT void JNICALL +Java_cvc5_Solver_declareSeparationHeap(JNIEnv* env, + jobject, + jlong pointer, + jlong locSortPointer, + jlong dataSortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* locSort = reinterpret_cast<Sort*>(locSortPointer); + Sort* dataSort = reinterpret_cast<Sort*>(dataSortPointer); + solver->declareSeparationHeap(*locSort, *dataSort); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: getSeparationHeap + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getSeparationHeap(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->getSeparationHeap()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getSeparationNilTerm + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getSeparationNilTerm(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* retPointer = new Term(solver->getSeparationNilTerm()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: pop + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_pop(JNIEnv* env, + jobject, + jlong pointer, + jint nscopes) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + solver->pop((uint32_t)nscopes); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: getInterpolant + * Signature: (JJJ)Z + */ +JNIEXPORT jboolean JNICALL Java_cvc5_Solver_getInterpolant__JJJ( + JNIEnv* env, jobject, jlong pointer, jlong conjPointer, jlong outputPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* conj = reinterpret_cast<Term*>(conjPointer); + Term* output = reinterpret_cast<Term*>(outputPointer); + return (jboolean)solver->getInterpolant(*conj, *output); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getInterpolant + * Signature: (JJJJ)Z + */ +JNIEXPORT jboolean JNICALL +Java_cvc5_Solver_getInterpolant__JJJJ(JNIEnv* env, + jobject, + jlong pointer, + jlong conjPointer, + jlong grammarPointer, + jlong outputPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* conj = reinterpret_cast<Term*>(conjPointer); + Grammar* grammar = reinterpret_cast<Grammar*>(grammarPointer); + Term* output = reinterpret_cast<Term*>(outputPointer); + return (jboolean)solver->getInterpolant(*conj, *grammar, *output); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getAbduct + * Signature: (JJJ)Z + */ +JNIEXPORT jboolean JNICALL Java_cvc5_Solver_getAbduct__JJJ( + JNIEnv* env, jobject, jlong pointer, jlong conjPointer, jlong outputPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* conj = reinterpret_cast<Term*>(conjPointer); + Term* output = reinterpret_cast<Term*>(outputPointer); + return (jboolean)solver->getAbduct(*conj, *output); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getAbduct + * Signature: (JJJJ)Z + */ +JNIEXPORT jboolean JNICALL +Java_cvc5_Solver_getAbduct__JJJJ(JNIEnv* env, + jobject, + jlong pointer, + jlong conjPointer, + jlong grammarPointer, + jlong outputPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* conj = reinterpret_cast<Term*>(conjPointer); + Grammar* grammar = reinterpret_cast<Grammar*>(grammarPointer); + Term* output = reinterpret_cast<Term*>(outputPointer); + return (jboolean)solver->getAbduct(*conj, *grammar, *output); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: blockModel + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_blockModel(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + solver->blockModel(); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: blockModelValues + * Signature: (J[J)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_blockModelValues(JNIEnv* env, + jobject, + jlong pointer, + jlongArray jTerms) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> terms = getObjectsFromPointers<Term>(env, jTerms); + solver->blockModelValues(terms); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: push + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_push(JNIEnv* env, + jobject, + jlong pointer, + jint nscopes) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + solver->push((uint32_t)nscopes); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: resetAssertions + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_resetAssertions(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + solver->resetAssertions(); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: setInfo + * Signature: (JLjava/lang/String;Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_setInfo( + JNIEnv* env, jobject, jlong pointer, jstring jKeyword, jstring jValue) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* sKeyword = env->GetStringUTFChars(jKeyword, nullptr); + const char* sValue = env->GetStringUTFChars(jValue, nullptr); + std::string cKeyword(sKeyword); + std::string cValue(sValue); + solver->setInfo(cKeyword, cValue); + env->ReleaseStringUTFChars(jKeyword, sKeyword); + env->ReleaseStringUTFChars(jValue, sValue); + CVC5_JAVA_API_TRY_CATCH_END(env); } /* * Class: cvc5_Solver * Method: setLogic - * Signature: (Ljava/lang/String;)V + * Signature: (JLjava/lang/String;)V */ JNIEXPORT void JNICALL Java_cvc5_Solver_setLogic(JNIEnv* env, - jobject, - jlong solverPointer, - jstring jLogic) + jobject, + jlong pointer, + jstring jLogic) { CVC5_JAVA_API_TRY_CATCH_BEGIN; - Solver* solver = (Solver*)solverPointer; + Solver* solver = reinterpret_cast<Solver*>(pointer); const char* cLogic = env->GetStringUTFChars(jLogic, nullptr); solver->setLogic(std::string(cLogic)); CVC5_JAVA_API_TRY_CATCH_END(env); } + +/* + * Class: cvc5_Solver + * Method: setOption + * Signature: (JLjava/lang/String;Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_setOption( + JNIEnv* env, jobject, jlong pointer, jstring jOption, jstring jValue) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* sOption = env->GetStringUTFChars(jOption, nullptr); + const char* sValue = env->GetStringUTFChars(jValue, nullptr); + std::string cOption(sOption); + std::string cValue(sValue); + solver->setOption(cOption, cValue); + env->ReleaseStringUTFChars(jOption, sOption); + env->ReleaseStringUTFChars(jValue, sValue); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: ensureTermSort + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_ensureTermSort( + JNIEnv* env, jobject, jlong pointer, jlong termPointer, jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Term* retPointer = new Term(solver->ensureTermSort(*term, *sort)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkSygusVar + * Signature: (JJLjava/lang/String;)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkSygusVar( + JNIEnv* env, jobject, jlong pointer, jlong sortPointer, jstring jSymbol) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + Term* retPointer = new Term(solver->mkSygusVar(*sort, cSymbol)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: mkSygusGrammar + * Signature: (J[J[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_mkSygusGrammar(JNIEnv* env, + jobject, + jlong pointer, + jlongArray jBoundVars, + jlongArray jNtSymbols) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> boundVars = getObjectsFromPointers<Term>(env, jBoundVars); + std::vector<Term> ntSymbols = getObjectsFromPointers<Term>(env, jNtSymbols); + Grammar* retPointer = + new Grammar(solver->mkSygusGrammar(boundVars, ntSymbols)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: synthFun + * Signature: (JLjava/lang/String;[JJ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_synthFun__JLjava_lang_String_2_3JJ(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol, + jlongArray jVars, + jlong sortPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Term> boundVars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = new Term(solver->synthFun(cSymbol, boundVars, *sort)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: synthFun + * Signature: (JLjava/lang/String;[JJJ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_synthFun__JLjava_lang_String_2_3JJJ(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol, + jlongArray jVars, + jlong sortPointer, + jlong grammarPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Sort* sort = reinterpret_cast<Sort*>(sortPointer); + Grammar* grammar = reinterpret_cast<Grammar*>(grammarPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Term> boundVars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = + new Term(solver->synthFun(cSymbol, boundVars, *sort, *grammar)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: synthInv + * Signature: (JLjava/lang/String;[J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_synthInv__JLjava_lang_String_2_3J( + JNIEnv* env, jobject, jlong pointer, jstring jSymbol, jlongArray jVars) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = new Term(solver->synthInv(cSymbol, vars)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: synthInv + * Signature: (JLjava/lang/String;[JJ)J + */ +JNIEXPORT jlong JNICALL +Java_cvc5_Solver_synthInv__JLjava_lang_String_2_3JJ(JNIEnv* env, + jobject, + jlong pointer, + jstring jSymbol, + jlongArray jVars, + jlong grammarPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Grammar* grammar = reinterpret_cast<Grammar*>(grammarPointer); + const char* s = env->GetStringUTFChars(jSymbol, nullptr); + std::string cSymbol(s); + std::vector<Term> vars = getObjectsFromPointers<Term>(env, jVars); + Term* retPointer = new Term(solver->synthInv(cSymbol, vars, *grammar)); + env->ReleaseStringUTFChars(jSymbol, s); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: addSygusConstraint + * Signature: (JJ)V + */ +JNIEXPORT void JNICALL Java_cvc5_Solver_addSygusConstraint(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + solver->addSygusConstraint(*term); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: addSygusInvConstraint + * Signature: (JJJJJ)V + */ +JNIEXPORT void JNICALL +Java_cvc5_Solver_addSygusInvConstraint(JNIEnv* env, + jobject, + jlong pointer, + jlong invPointer, + jlong prePointer, + jlong transPointer, + jlong postPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* inv = reinterpret_cast<Term*>(invPointer); + Term* pre = reinterpret_cast<Term*>(prePointer); + Term* trans = reinterpret_cast<Term*>(transPointer); + Term* post = reinterpret_cast<Term*>(postPointer); + solver->addSygusInvConstraint(*inv, *pre, *trans, *post); + CVC5_JAVA_API_TRY_CATCH_END(env); +} + +/* + * Class: cvc5_Solver + * Method: checkSynth + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_checkSynth(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Result* retPointer = new Result(solver->checkSynth()); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getSynthSolution + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getSynthSolution(JNIEnv* env, + jobject, + jlong pointer, + jlong termPointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + Term* term = reinterpret_cast<Term*>(termPointer); + Term* retPointer = new Term(solver->getSynthSolution(*term)); + return reinterpret_cast<jlong>(retPointer); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getSynthSolutions + * Signature: (J[J)[J + */ +JNIEXPORT jlongArray JNICALL Java_cvc5_Solver_getSynthSolutions( + JNIEnv* env, jobject, jlong pointer, jlongArray jTerms) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Solver* solver = reinterpret_cast<Solver*>(pointer); + std::vector<Term> terms = getObjectsFromPointers<Term>(env, jTerms); + std::vector<Term> solutions = solver->getSynthSolutions(terms); + jlongArray ret = getPointersFromObjects<Term>(env, solutions); + return ret; + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, nullptr); +} + +/* + * Class: cvc5_Solver + * Method: getNullTerm + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getNullTerm(JNIEnv* env, + jobject, + jlong) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Term* ret = new Term(); + return reinterpret_cast<jlong>(ret); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getNullResult + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getNullResult(JNIEnv* env, + jobject, + jlong) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Result* ret = new Result(); + return reinterpret_cast<jlong>(ret); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getNullOp + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getNullOp(JNIEnv* env, jobject, jlong) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Op* ret = new Op(); + return reinterpret_cast<jlong>(ret); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Solver + * Method: getNullDatatypeDecl + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_cvc5_Solver_getNullDatatypeDecl(JNIEnv* env, + jobject, + jlong) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + DatatypeDecl* ret = new DatatypeDecl(); + return reinterpret_cast<jlong>(ret); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +}
\ No newline at end of file diff --git a/src/api/java/jni/cvc5_Term.cpp b/src/api/java/jni/cvc5_Term.cpp index 6c4d00ff3..0de1b5673 100644 --- a/src/api/java/jni/cvc5_Term.cpp +++ b/src/api/java/jni/cvc5_Term.cpp @@ -572,6 +572,37 @@ JNIEXPORT jstring JNICALL Java_cvc5_Term_getString(JNIEnv* env, /* * Class: cvc5_Term + * Method: isRealValue + * Signature: (J)Z + */ +JNIEXPORT jboolean JNICALL Java_cvc5_Term_isRealValue(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Term* current = reinterpret_cast<Term*>(pointer); + return static_cast<jboolean>(current->isRealValue()); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, static_cast<jboolean>(false)); +} + +/* + * Class: cvc5_Term + * Method: getRealValue + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_cvc5_Term_getRealValue(JNIEnv* env, + jobject, + jlong pointer) +{ + CVC5_JAVA_API_TRY_CATCH_BEGIN; + Term* current = reinterpret_cast<Term*>(pointer); + std::string realValue = current->getRealValue(); + return env->NewStringUTF(realValue.c_str()); + CVC5_JAVA_API_TRY_CATCH_END_RETURN(env, 0); +} + +/* + * Class: cvc5_Term * Method: iterator * Signature: (J)J */ diff --git a/test/unit/api/java/CMakeLists.txt b/test/unit/api/java/CMakeLists.txt index fe497ef3b..66b764ca4 100644 --- a/test/unit/api/java/CMakeLists.txt +++ b/test/unit/api/java/CMakeLists.txt @@ -21,7 +21,13 @@ get_target_property(CVC5_JAR_PATH cvc5jar JAR_FILE) # specify source files for junit tests set(java_test_src_files + ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/DatatypeTest.java + ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/GrammarTest.java + ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/OpTest.java + ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/ResultTest.java ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/SolverTest.java + ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/SortTest.java + ${CMAKE_CURRENT_SOURCE_DIR}/cvc5/TermTest.java ) # build junit tests @@ -59,4 +65,5 @@ add_custom_target( ) add_dependencies(run-junit-tests build-junit-tests) -add_dependencies(units run-junit-tests)
\ No newline at end of file +add_dependencies(units run-junit-tests) +add_dependencies(check run-junit-tests)
\ No newline at end of file diff --git a/test/unit/api/java/cvc5/GrammarTest.java b/test/unit/api/java/cvc5/GrammarTest.java index 76a80f55e..6e7c6ce5e 100644 --- a/test/unit/api/java/cvc5/GrammarTest.java +++ b/test/unit/api/java/cvc5/GrammarTest.java @@ -23,16 +23,17 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -class GrammarTest { +class GrammarTest +{ private Solver d_solver; - @BeforeEach - void setUp() { + @BeforeEach void setUp() + { d_solver = new Solver(); } - @Test - void addRule() { + @Test void addRule() + { Sort bool = d_solver.getBooleanSort(); Sort integer = d_solver.getIntegerSort(); @@ -44,23 +45,19 @@ class GrammarTest { assertDoesNotThrow(() -> g.addRule(start, d_solver.mkBoolean(false))); - assertThrows(CVC5ApiException.class, - () -> g.addRule(nullTerm, d_solver.mkBoolean(false))); + assertThrows(CVC5ApiException.class, () -> g.addRule(nullTerm, d_solver.mkBoolean(false))); assertThrows(CVC5ApiException.class, () -> g.addRule(start, nullTerm)); - assertThrows(CVC5ApiException.class, - () -> g.addRule(nts, d_solver.mkBoolean(false))); - assertThrows( - CVC5ApiException.class, () -> g.addRule(start, d_solver.mkInteger(0))); + assertThrows(CVC5ApiException.class, () -> g.addRule(nts, d_solver.mkBoolean(false))); + assertThrows(CVC5ApiException.class, () -> g.addRule(start, d_solver.mkInteger(0))); assertThrows(CVC5ApiException.class, () -> g.addRule(start, nts)); d_solver.synthFun("f", new Term[] {}, bool, g); - assertThrows(CVC5ApiException.class, - () -> g.addRule(start, d_solver.mkBoolean(false))); + assertThrows(CVC5ApiException.class, () -> g.addRule(start, d_solver.mkBoolean(false))); } - @Test - void addRules() { + @Test void addRules() + { Sort bool = d_solver.getBooleanSort(); Sort integer = d_solver.getIntegerSort(); @@ -70,28 +67,25 @@ class GrammarTest { Grammar g = d_solver.mkSygusGrammar(new Term[] {}, new Term[] {start}); - assertDoesNotThrow( - () -> g.addRules(start, new Term[] {d_solver.mkBoolean(false)})); + assertDoesNotThrow(() -> g.addRules(start, new Term[] {d_solver.mkBoolean(false)})); - assertThrows(CVC5ApiException.class, - () -> g.addRules(nullTerm, new Term[] {d_solver.mkBoolean(false)})); assertThrows( - CVC5ApiException.class, () -> g.addRules(start, new Term[] {nullTerm})); - assertThrows(CVC5ApiException.class, - () -> g.addRules(nts, new Term[] {d_solver.mkBoolean(false)})); - assertThrows(CVC5ApiException.class, - () -> g.addRules(start, new Term[] {d_solver.mkInteger(0)})); + CVC5ApiException.class, () -> g.addRules(nullTerm, new Term[] {d_solver.mkBoolean(false)})); + assertThrows(CVC5ApiException.class, () -> g.addRules(start, new Term[] {nullTerm})); + assertThrows( + CVC5ApiException.class, () -> g.addRules(nts, new Term[] {d_solver.mkBoolean(false)})); assertThrows( - CVC5ApiException.class, () -> g.addRules(start, new Term[] {nts})); + CVC5ApiException.class, () -> g.addRules(start, new Term[] {d_solver.mkInteger(0)})); + assertThrows(CVC5ApiException.class, () -> g.addRules(start, new Term[] {nts})); d_solver.synthFun("f", new Term[] {}, bool, g); - assertThrows(CVC5ApiException.class, - () -> g.addRules(start, new Term[] {d_solver.mkBoolean(false)})); + assertThrows( + CVC5ApiException.class, () -> g.addRules(start, new Term[] {d_solver.mkBoolean(false)})); } - @Test - void addAnyConstant() { + @Test void addAnyConstant() + { Sort bool = d_solver.getBooleanSort(); Term nullTerm = d_solver.getNullTerm(); @@ -111,8 +105,8 @@ class GrammarTest { assertThrows(CVC5ApiException.class, () -> g.addAnyConstant(start)); } - @Test - void addAnyVariable() { + @Test void addAnyVariable() + { Sort bool = d_solver.getBooleanSort(); Term nullTerm = d_solver.getNullTerm(); diff --git a/test/unit/api/java/cvc5/OpTest.java b/test/unit/api/java/cvc5/OpTest.java index afe728b88..f4dd181f4 100644 --- a/test/unit/api/java/cvc5/OpTest.java +++ b/test/unit/api/java/cvc5/OpTest.java @@ -23,38 +23,38 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -class OpTest { +class OpTest +{ private Solver d_solver; - @BeforeEach - void setUp() { + @BeforeEach void setUp() + { d_solver = new Solver(); } - @Test - void getKind() throws CVC5ApiException { + @Test void getKind() throws CVC5ApiException + { Op x; x = d_solver.mkOp(BITVECTOR_EXTRACT, 31, 1); assertDoesNotThrow(() -> x.getKind()); } - @Test - void isNull() throws CVC5ApiException { + @Test void isNull() throws CVC5ApiException + { Op x = d_solver.getNullOp(); assertTrue(x.isNull()); x = d_solver.mkOp(BITVECTOR_EXTRACT, 31, 1); assertFalse(x.isNull()); } - @Test - void opFromKind() { + @Test void opFromKind() + { assertDoesNotThrow(() -> d_solver.mkOp(PLUS)); - assertThrows( - CVC5ApiException.class, () -> d_solver.mkOp(BITVECTOR_EXTRACT)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkOp(BITVECTOR_EXTRACT)); } - @Test - void getIndicesString() throws CVC5ApiException { + @Test void getIndicesString() throws CVC5ApiException + { Op x = d_solver.getNullOp(); assertThrows(CVC5ApiException.class, () -> x.getStringIndices()); @@ -64,8 +64,8 @@ class OpTest { assertEquals(divisible_idx, "4"); } - @Test - void getIndicesUint() throws CVC5ApiException { + @Test void getIndicesUint() throws CVC5ApiException + { Op bitvector_repeat_ot = d_solver.mkOp(BITVECTOR_REPEAT, 5); assertTrue(bitvector_repeat_ot.isIndexed()); int bitvector_repeat_idx = bitvector_repeat_ot.getIntegerIndices()[0]; @@ -77,23 +77,19 @@ class OpTest { // () -> bitvector_repeat_ot.getIntegerIndices()); Op bitvector_zero_extend_ot = d_solver.mkOp(BITVECTOR_ZERO_EXTEND, 6); - int bitvector_zero_extend_idx = - bitvector_zero_extend_ot.getIntegerIndices()[0]; + int bitvector_zero_extend_idx = bitvector_zero_extend_ot.getIntegerIndices()[0]; assertEquals(bitvector_zero_extend_idx, 6); Op bitvector_sign_extend_ot = d_solver.mkOp(BITVECTOR_SIGN_EXTEND, 7); - int bitvector_sign_extend_idx = - bitvector_sign_extend_ot.getIntegerIndices()[0]; + int bitvector_sign_extend_idx = bitvector_sign_extend_ot.getIntegerIndices()[0]; assertEquals(bitvector_sign_extend_idx, 7); Op bitvector_rotate_left_ot = d_solver.mkOp(BITVECTOR_ROTATE_LEFT, 8); - int bitvector_rotate_left_idx = - bitvector_rotate_left_ot.getIntegerIndices()[0]; + int bitvector_rotate_left_idx = bitvector_rotate_left_ot.getIntegerIndices()[0]; assertEquals(bitvector_rotate_left_idx, 8); Op bitvector_rotate_right_ot = d_solver.mkOp(BITVECTOR_ROTATE_RIGHT, 9); - int bitvector_rotate_right_idx = - bitvector_rotate_right_ot.getIntegerIndices()[0]; + int bitvector_rotate_right_idx = bitvector_rotate_right_ot.getIntegerIndices()[0]; assertEquals(bitvector_rotate_right_idx, 9); Op int_to_bitvector_ot = d_solver.mkOp(INT_TO_BITVECTOR, 10); @@ -101,18 +97,16 @@ class OpTest { assertEquals(int_to_bitvector_idx, 10); Op floatingpoint_to_ubv_ot = d_solver.mkOp(FLOATINGPOINT_TO_UBV, 11); - int floatingpoint_to_ubv_idx = - floatingpoint_to_ubv_ot.getIntegerIndices()[0]; + int floatingpoint_to_ubv_idx = floatingpoint_to_ubv_ot.getIntegerIndices()[0]; assertEquals(floatingpoint_to_ubv_idx, 11); Op floatingpoint_to_sbv_ot = d_solver.mkOp(FLOATINGPOINT_TO_SBV, 13); - int floatingpoint_to_sbv_idx = - floatingpoint_to_sbv_ot.getIntegerIndices()[0]; + int floatingpoint_to_sbv_idx = floatingpoint_to_sbv_ot.getIntegerIndices()[0]; assertEquals(floatingpoint_to_sbv_idx, 13); } - @Test - void getIndicesPairUint() throws CVC5ApiException { + @Test void getIndicesPairUint() throws CVC5ApiException + { Op bitvector_extract_ot = d_solver.mkOp(BITVECTOR_EXTRACT, 4, 0); assertTrue(bitvector_extract_ot.isIndexed()); int[] bitvector_extract_indices = bitvector_extract_ot.getIntegerIndices(); @@ -122,47 +116,38 @@ class OpTest { d_solver.mkOp(FLOATINGPOINT_TO_FP_IEEE_BITVECTOR, 4, 25); int[] floatingpoint_to_fp_ieee_bitvector_indices = floatingpoint_to_fp_ieee_bitvector_ot.getIntegerIndices(); - assertArrayEquals( - floatingpoint_to_fp_ieee_bitvector_indices, new int[] {4, 25}); + assertArrayEquals(floatingpoint_to_fp_ieee_bitvector_indices, new int[] {4, 25}); Op floatingpoint_to_fp_floatingpoint_ot = d_solver.mkOp(FLOATINGPOINT_TO_FP_FLOATINGPOINT, 4, 25); int[] floatingpoint_to_fp_floatingpoint_indices = floatingpoint_to_fp_floatingpoint_ot.getIntegerIndices(); - assertArrayEquals( - floatingpoint_to_fp_floatingpoint_indices, new int[] {4, 25}); + assertArrayEquals(floatingpoint_to_fp_floatingpoint_indices, new int[] {4, 25}); - Op floatingpoint_to_fp_real_ot = - d_solver.mkOp(FLOATINGPOINT_TO_FP_REAL, 4, 25); - int[] floatingpoint_to_fp_real_indices = - floatingpoint_to_fp_real_ot.getIntegerIndices(); + Op floatingpoint_to_fp_real_ot = d_solver.mkOp(FLOATINGPOINT_TO_FP_REAL, 4, 25); + int[] floatingpoint_to_fp_real_indices = floatingpoint_to_fp_real_ot.getIntegerIndices(); assertArrayEquals(floatingpoint_to_fp_real_indices, new int[] {4, 25}); Op floatingpoint_to_fp_signed_bitvector_ot = d_solver.mkOp(FLOATINGPOINT_TO_FP_SIGNED_BITVECTOR, 4, 25); int[] floatingpoint_to_fp_signed_bitvector_indices = floatingpoint_to_fp_signed_bitvector_ot.getIntegerIndices(); - assertArrayEquals( - floatingpoint_to_fp_signed_bitvector_indices, new int[] {4, 25}); + assertArrayEquals(floatingpoint_to_fp_signed_bitvector_indices, new int[] {4, 25}); Op floatingpoint_to_fp_unsigned_bitvector_ot = d_solver.mkOp(FLOATINGPOINT_TO_FP_UNSIGNED_BITVECTOR, 4, 25); int[] floatingpoint_to_fp_unsigned_bitvector_indices = floatingpoint_to_fp_unsigned_bitvector_ot.getIntegerIndices(); - assertArrayEquals( - floatingpoint_to_fp_unsigned_bitvector_indices, new int[] {4, 25}); + assertArrayEquals(floatingpoint_to_fp_unsigned_bitvector_indices, new int[] {4, 25}); - Op floatingpoint_to_fp_generic_ot = - d_solver.mkOp(FLOATINGPOINT_TO_FP_GENERIC, 4, 25); - int[] floatingpoint_to_fp_generic_indices = - floatingpoint_to_fp_generic_ot.getIntegerIndices(); + Op floatingpoint_to_fp_generic_ot = d_solver.mkOp(FLOATINGPOINT_TO_FP_GENERIC, 4, 25); + int[] floatingpoint_to_fp_generic_indices = floatingpoint_to_fp_generic_ot.getIntegerIndices(); assertArrayEquals(floatingpoint_to_fp_generic_indices, new int[] {4, 25}); - assertThrows(CVC5ApiException.class, - () -> floatingpoint_to_fp_generic_ot.getStringIndices()); + assertThrows(CVC5ApiException.class, () -> floatingpoint_to_fp_generic_ot.getStringIndices()); } - @Test - void opScopingToString() throws CVC5ApiException { + @Test void opScopingToString() throws CVC5ApiException + { Op bitvector_repeat_ot = d_solver.mkOp(BITVECTOR_REPEAT, 5); String op_repr = bitvector_repeat_ot.toString(); diff --git a/test/unit/api/java/cvc5/SolverTest.java b/test/unit/api/java/cvc5/SolverTest.java index 57758ff88..18560f2dc 100644 --- a/test/unit/api/java/cvc5/SolverTest.java +++ b/test/unit/api/java/cvc5/SolverTest.java @@ -13,11 +13,14 @@ * Black box testing of the Solver class of the Java API. */ - package cvc5; +import static cvc5.Kind.*; +import static cvc5.RoundingMode.*; import static org.junit.jupiter.api.Assertions.*; +import java.util.*; +import java.util.concurrent.atomic.AtomicReference; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -31,14 +34,2312 @@ class SolverTest d_solver = new Solver(); } - @AfterEach void tearDown() + @Test void recoverableException() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x).notTerm()); + assertThrows(CVC5ApiRecoverableException.class, () -> d_solver.getValue(x)); + } + + @Test void supportsFloatingPoint() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkRoundingMode(ROUND_NEAREST_TIES_TO_EVEN)); + } + + @Test void getBooleanSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.getBooleanSort()); + } + + @Test void getIntegerSort() + { + assertDoesNotThrow(() -> d_solver.getIntegerSort()); + } + + @Test void getNullSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.getNullSort()); + } + + @Test void getRealSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.getRealSort()); + } + + @Test void getRegExpSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.getRegExpSort()); + } + + @Test void getStringSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.getStringSort()); + } + + @Test void getRoundingModeSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.getRoundingModeSort()); + } + + @Test void mkArraySort() throws CVC5ApiException + { + Sort boolSort = d_solver.getBooleanSort(); + Sort intSort = d_solver.getIntegerSort(); + Sort realSort = d_solver.getRealSort(); + Sort bvSort = d_solver.mkBitVectorSort(32); + assertDoesNotThrow(() -> d_solver.mkArraySort(boolSort, boolSort)); + assertDoesNotThrow(() -> d_solver.mkArraySort(intSort, intSort)); + assertDoesNotThrow(() -> d_solver.mkArraySort(realSort, realSort)); + assertDoesNotThrow(() -> d_solver.mkArraySort(bvSort, bvSort)); + assertDoesNotThrow(() -> d_solver.mkArraySort(boolSort, intSort)); + assertDoesNotThrow(() -> d_solver.mkArraySort(realSort, bvSort)); + + Sort fpSort = d_solver.mkFloatingPointSort(3, 5); + assertDoesNotThrow(() -> d_solver.mkArraySort(fpSort, fpSort)); + assertDoesNotThrow(() -> d_solver.mkArraySort(bvSort, fpSort)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkArraySort(boolSort, boolSort)); + } + + @Test void mkBitVectorSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkBitVectorSort(32)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVectorSort(0)); + } + + @Test void mkFloatingPointSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkFloatingPointSort(4, 8)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkFloatingPointSort(0, 8)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkFloatingPointSort(4, 0)); + } + + @Test void mkDatatypeSort() throws CVC5ApiException + { + DatatypeDecl dtypeSpec = d_solver.mkDatatypeDecl("list"); + DatatypeConstructorDecl cons = d_solver.mkDatatypeConstructorDecl("cons"); + cons.addSelector("head", d_solver.getIntegerSort()); + dtypeSpec.addConstructor(cons); + DatatypeConstructorDecl nil = d_solver.mkDatatypeConstructorDecl("nil"); + dtypeSpec.addConstructor(nil); + assertDoesNotThrow(() -> d_solver.mkDatatypeSort(dtypeSpec)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkDatatypeSort(dtypeSpec)); + + DatatypeDecl throwsDtypeSpec = d_solver.mkDatatypeDecl("list"); + assertThrows(CVC5ApiException.class, () -> d_solver.mkDatatypeSort(throwsDtypeSpec)); + } + + @Test void mkDatatypeSorts() throws CVC5ApiException + { + Solver slv = new Solver(); + + DatatypeDecl dtypeSpec1 = d_solver.mkDatatypeDecl("list1"); + DatatypeConstructorDecl cons1 = d_solver.mkDatatypeConstructorDecl("cons1"); + cons1.addSelector("head1", d_solver.getIntegerSort()); + dtypeSpec1.addConstructor(cons1); + DatatypeConstructorDecl nil1 = d_solver.mkDatatypeConstructorDecl("nil1"); + dtypeSpec1.addConstructor(nil1); + DatatypeDecl dtypeSpec2 = d_solver.mkDatatypeDecl("list2"); + DatatypeConstructorDecl cons2 = d_solver.mkDatatypeConstructorDecl("cons2"); + cons2.addSelector("head2", d_solver.getIntegerSort()); + dtypeSpec2.addConstructor(cons2); + DatatypeConstructorDecl nil2 = d_solver.mkDatatypeConstructorDecl("nil2"); + dtypeSpec2.addConstructor(nil2); + DatatypeDecl[] decls = {dtypeSpec1, dtypeSpec2}; + assertDoesNotThrow(() -> d_solver.mkDatatypeSorts(decls)); + + assertThrows(CVC5ApiException.class, () -> slv.mkDatatypeSorts(decls)); + + DatatypeDecl throwsDtypeSpec = d_solver.mkDatatypeDecl("list"); + DatatypeDecl[] throwsDecls = new DatatypeDecl[] {throwsDtypeSpec}; + assertThrows(CVC5ApiException.class, () -> d_solver.mkDatatypeSorts(throwsDecls)); + + /* with unresolved sorts */ + Sort unresList = d_solver.mkUninterpretedSort("ulist"); + Set<Sort> unresSorts = new HashSet<>(); + unresSorts.add(unresList); + DatatypeDecl ulist = d_solver.mkDatatypeDecl("ulist"); + DatatypeConstructorDecl ucons = d_solver.mkDatatypeConstructorDecl("ucons"); + ucons.addSelector("car", unresList); + ucons.addSelector("cdr", unresList); + ulist.addConstructor(ucons); + DatatypeConstructorDecl unil = d_solver.mkDatatypeConstructorDecl("unil"); + ulist.addConstructor(unil); + DatatypeDecl[] udecls = new DatatypeDecl[] {ulist}; + assertDoesNotThrow(() -> d_solver.mkDatatypeSorts(Arrays.asList(udecls), unresSorts)); + + assertThrows( + CVC5ApiException.class, () -> slv.mkDatatypeSorts(Arrays.asList(udecls), unresSorts)); + + /* Note: More tests are in datatype_api_black. */ + } + + @Test void mkFunctionSort() throws CVC5ApiException + { + assertDoesNotThrow(() + -> d_solver.mkFunctionSort( + d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort())); + Sort funSort = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + // function arguments are allowed + assertDoesNotThrow(() -> d_solver.mkFunctionSort(funSort, d_solver.getIntegerSort())); + // non-first-class arguments are not allowed + Sort reSort = d_solver.getRegExpSort(); + assertThrows( + CVC5ApiException.class, () -> d_solver.mkFunctionSort(reSort, d_solver.getIntegerSort())); + + assertThrows( + CVC5ApiException.class, () -> d_solver.mkFunctionSort(d_solver.getIntegerSort(), funSort)); + + assertDoesNotThrow(() + -> d_solver.mkFunctionSort(new Sort[] {d_solver.mkUninterpretedSort("u"), + d_solver.getIntegerSort()}, + d_solver.getIntegerSort())); + Sort funSort2 = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + // function arguments are allowed + assertDoesNotThrow( + () + -> d_solver.mkFunctionSort(new Sort[] {funSort2, d_solver.mkUninterpretedSort("u")}, + d_solver.getIntegerSort())); + assertThrows(CVC5ApiException.class, + () + -> d_solver.mkFunctionSort( + new Sort[] {d_solver.getIntegerSort(), d_solver.mkUninterpretedSort("u")}, + funSort2)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, + () -> slv.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort())); + + assertThrows(CVC5ApiException.class, + () -> slv.mkFunctionSort(slv.mkUninterpretedSort("u"), d_solver.getIntegerSort())); + + Sort[] sorts1 = + new Sort[] {d_solver.getBooleanSort(), slv.getIntegerSort(), d_solver.getIntegerSort()}; + Sort[] sorts2 = new Sort[] {slv.getBooleanSort(), slv.getIntegerSort()}; + assertDoesNotThrow(() -> slv.mkFunctionSort(sorts2, slv.getIntegerSort())); + assertThrows(CVC5ApiException.class, () -> slv.mkFunctionSort(sorts1, slv.getIntegerSort())); + assertThrows( + CVC5ApiException.class, () -> slv.mkFunctionSort(sorts2, d_solver.getIntegerSort())); + } + + @Test void mkParamSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkParamSort("T")); + assertDoesNotThrow(() -> d_solver.mkParamSort("")); + } + + @Test void mkPredicateSort() + { + assertDoesNotThrow(() -> d_solver.mkPredicateSort(new Sort[] {d_solver.getIntegerSort()})); + assertThrows(CVC5ApiException.class, () -> d_solver.mkPredicateSort(new Sort[] {})); + Sort funSort = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + // functions as arguments are allowed + assertDoesNotThrow( + () -> d_solver.mkPredicateSort(new Sort[] {d_solver.getIntegerSort(), funSort})); + + Solver slv = new Solver(); + assertThrows( + CVC5ApiException.class, () -> slv.mkPredicateSort(new Sort[] {d_solver.getIntegerSort()})); + } + + @Test void mkRecordSort() throws CVC5ApiException + { + Pair<String, Sort>[] fields = new Pair[] {new Pair<>("b", d_solver.getBooleanSort()), + new Pair<>("bv", d_solver.mkBitVectorSort(8)), + new Pair<>("i", d_solver.getIntegerSort())}; + Pair<String, Sort>[] empty = new Pair[0]; + assertDoesNotThrow(() -> d_solver.mkRecordSort(fields)); + assertDoesNotThrow(() -> d_solver.mkRecordSort(empty)); + Sort recSort = d_solver.mkRecordSort(fields); + assertDoesNotThrow(() -> recSort.getDatatype()); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkRecordSort(fields)); + } + + @Test void mkSetSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkSetSort(d_solver.getBooleanSort())); + assertDoesNotThrow(() -> d_solver.mkSetSort(d_solver.getIntegerSort())); + assertDoesNotThrow(() -> d_solver.mkSetSort(d_solver.mkBitVectorSort(4))); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkSetSort(d_solver.mkBitVectorSort(4))); + } + + @Test void mkBagSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkBagSort(d_solver.getBooleanSort())); + assertDoesNotThrow(() -> d_solver.mkBagSort(d_solver.getIntegerSort())); + assertDoesNotThrow(() -> d_solver.mkBagSort(d_solver.mkBitVectorSort(4))); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkBagSort(d_solver.mkBitVectorSort(4))); + } + + @Test void mkSequenceSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkSequenceSort(d_solver.getBooleanSort())); + assertDoesNotThrow( + () -> d_solver.mkSequenceSort(d_solver.mkSequenceSort(d_solver.getIntegerSort()))); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkSequenceSort(d_solver.getIntegerSort())); + } + + @Test void mkUninterpretedSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkUninterpretedSort("u")); + assertDoesNotThrow(() -> d_solver.mkUninterpretedSort("")); + } + + @Test void mkSortConstructorSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkSortConstructorSort("s", 2)); + assertDoesNotThrow(() -> d_solver.mkSortConstructorSort("", 2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkSortConstructorSort("", 0)); + } + + @Test void mkTupleSort() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkTupleSort(new Sort[] {d_solver.getIntegerSort()})); + Sort funSort = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTupleSort(new Sort[] {d_solver.getIntegerSort(), funSort})); + + Solver slv = new Solver(); + assertThrows( + CVC5ApiException.class, () -> slv.mkTupleSort(new Sort[] {d_solver.getIntegerSort()})); + } + + @Test void mkBitVector() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkBitVector(8, 2)); + assertDoesNotThrow(() -> d_solver.mkBitVector(32, 2)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "-1111111", 2)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "0101", 2)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "00000101", 2)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "-127", 10)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "255", 10)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "-7f", 16)); + assertDoesNotThrow(() -> d_solver.mkBitVector(8, "a0", 16)); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(0, 2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(0, "-127", 10)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(0, "a0", 16)); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "", 2)); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "101", 5)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "128", 11)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "a0", 21)); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "-11111111", 2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "101010101", 2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "-256", 10)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "257", 10)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "-a0", 16)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "fffff", 16)); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "10201010", 2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "-25x", 10)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "2x7", 10)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkBitVector(8, "fzff", 16)); + + assertEquals(d_solver.mkBitVector(8, "0101", 2), d_solver.mkBitVector(8, "00000101", 2)); + assertEquals(d_solver.mkBitVector(4, "-1", 2), d_solver.mkBitVector(4, "1111", 2)); + assertEquals(d_solver.mkBitVector(4, "-1", 16), d_solver.mkBitVector(4, "1111", 2)); + assertEquals(d_solver.mkBitVector(4, "-1", 10), d_solver.mkBitVector(4, "1111", 2)); + assertEquals(d_solver.mkBitVector(8, "01010101", 2).toString(), "#b01010101"); + assertEquals(d_solver.mkBitVector(8, "F", 16).toString(), "#b00001111"); + assertEquals(d_solver.mkBitVector(8, "-1", 10), d_solver.mkBitVector(8, "FF", 16)); + } + + @Test void mkVar() throws CVC5ApiException + { + Sort boolSort = d_solver.getBooleanSort(); + Sort intSort = d_solver.getIntegerSort(); + Sort funSort = d_solver.mkFunctionSort(intSort, boolSort); + assertDoesNotThrow(() -> d_solver.mkVar(boolSort)); + assertDoesNotThrow(() -> d_solver.mkVar(funSort)); + assertDoesNotThrow(() -> d_solver.mkVar(boolSort, ("b"))); + assertDoesNotThrow(() -> d_solver.mkVar(funSort, "")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkVar(d_solver.getNullSort())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkVar(d_solver.getNullSort(), "a")); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkVar(boolSort, "x")); + } + + @Test void mkBoolean() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkBoolean(true)); + assertDoesNotThrow(() -> d_solver.mkBoolean(false)); + } + + @Test void mkRoundingMode() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkRoundingMode(RoundingMode.ROUND_TOWARD_ZERO)); + } + + @Test void mkUninterpretedConst() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkUninterpretedConst(d_solver.getBooleanSort(), 1)); + assertThrows( + CVC5ApiException.class, () -> d_solver.mkUninterpretedConst(d_solver.getNullSort(), 1)); + Solver slv = new Solver(); + assertThrows( + CVC5ApiException.class, () -> slv.mkUninterpretedConst(d_solver.getBooleanSort(), 1)); + } + + @Test void mkAbstractValue() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkAbstractValue(("1"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkAbstractValue(("0"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkAbstractValue(("-1"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkAbstractValue(("1.2"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkAbstractValue("1/2")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkAbstractValue("asdf")); + + assertDoesNotThrow(() -> d_solver.mkAbstractValue((int) 1)); + assertDoesNotThrow(() -> d_solver.mkAbstractValue((int) 1)); + assertDoesNotThrow(() -> d_solver.mkAbstractValue((long) 1)); + assertDoesNotThrow(() -> d_solver.mkAbstractValue((long) 1)); + // java does not have specific types for unsigned integers, therefore the two lines below do not + // make sense in java. assertDoesNotThrow(() -> d_solver.mkAbstractValue((int)-1)); + // assertDoesNotThrow(() -> d_solver.mkAbstractValue((long)-1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkAbstractValue(0)); + } + + @Test void mkFloatingPoint() throws CVC5ApiException + { + Term t1 = d_solver.mkBitVector(8); + Term t2 = d_solver.mkBitVector(4); + Term t3 = d_solver.mkInteger(2); + assertDoesNotThrow(() -> d_solver.mkFloatingPoint(3, 5, t1)); + + assertThrows( + CVC5ApiException.class, () -> d_solver.mkFloatingPoint(0, 5, d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkFloatingPoint(0, 5, t1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkFloatingPoint(3, 0, t1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkFloatingPoint(3, 5, t2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkFloatingPoint(3, 5, t2)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkFloatingPoint(3, 5, t1)); + } + + @Test void mkEmptySet() throws CVC5ApiException + { + Solver slv = new Solver(); + Sort s = d_solver.mkSetSort(d_solver.getBooleanSort()); + assertDoesNotThrow(() -> d_solver.mkEmptySet(d_solver.getNullSort())); + assertDoesNotThrow(() -> d_solver.mkEmptySet(s)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkEmptySet(d_solver.getBooleanSort())); + assertThrows(CVC5ApiException.class, () -> slv.mkEmptySet(s)); + } + + @Test void mkEmptyBag() throws CVC5ApiException + { + Solver slv = new Solver(); + Sort s = d_solver.mkBagSort(d_solver.getBooleanSort()); + assertDoesNotThrow(() -> d_solver.mkEmptyBag(d_solver.getNullSort())); + assertDoesNotThrow(() -> d_solver.mkEmptyBag(s)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkEmptyBag(d_solver.getBooleanSort())); + + assertThrows(CVC5ApiException.class, () -> slv.mkEmptyBag(s)); + } + + @Test void mkEmptySequence() throws CVC5ApiException + { + Solver slv = new Solver(); + Sort s = d_solver.mkSequenceSort(d_solver.getBooleanSort()); + assertDoesNotThrow(() -> d_solver.mkEmptySequence(s)); + assertDoesNotThrow(() -> d_solver.mkEmptySequence(d_solver.getBooleanSort())); + assertThrows(CVC5ApiException.class, () -> slv.mkEmptySequence(s)); + } + + @Test void mkFalse() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkFalse()); + assertDoesNotThrow(() -> d_solver.mkFalse()); + } + + @Test void mkNaN() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkNaN(3, 5)); + } + + @Test void mkNegZero() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.mkNegZero(3, 5)); + } + + @Test void mkNegInf() + { + assertDoesNotThrow(() -> d_solver.mkNegInf(3, 5)); + } + + @Test void mkPosInf() + { + assertDoesNotThrow(() -> d_solver.mkPosInf(3, 5)); + } + + @Test void mkPosZero() + { + assertDoesNotThrow(() -> d_solver.mkPosZero(3, 5)); + } + + @Test void mkOp() + { + // Unlike c++, mkOp(Kind kind, Kind k) is a type error in java + // assertThrows(CVC5ApiException.class, () -> d_solver.mkOp(BITVECTOR_EXTRACT, EQUAL)); + + // mkOp(Kind kind, const std::string& arg) + assertDoesNotThrow(() -> d_solver.mkOp(DIVISIBLE, "2147483648")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkOp(BITVECTOR_EXTRACT, "asdf")); + + // mkOp(Kind kind, int arg) + assertDoesNotThrow(() -> d_solver.mkOp(DIVISIBLE, 1)); + assertDoesNotThrow(() -> d_solver.mkOp(BITVECTOR_ROTATE_LEFT, 1)); + assertDoesNotThrow(() -> d_solver.mkOp(BITVECTOR_ROTATE_RIGHT, 1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkOp(BITVECTOR_EXTRACT, 1)); + + // mkOp(Kind kind, int arg1, int arg2) + assertDoesNotThrow(() -> d_solver.mkOp(BITVECTOR_EXTRACT, 1, 1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkOp(DIVISIBLE, 1, 2)); + + // mkOp(Kind kind, int[] args) + int[] args = new int[] {1, 2, 2}; + assertDoesNotThrow(() -> d_solver.mkOp(TUPLE_PROJECT, args)); + } + + @Test void mkPi() + { + assertDoesNotThrow(() -> d_solver.mkPi()); + } + + @Test void mkInteger() + { + assertDoesNotThrow(() -> d_solver.mkInteger("123")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("1.23")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("1/23")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("12/3")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(".2")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("2.")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("asdf")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("1.2/3")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(".")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("/")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("2/")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger("/2")); + + assertDoesNotThrow(() -> d_solver.mkReal(("123"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("1.23"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("1/23"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("12/3"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger((".2"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("2."))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger((""))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("asdf"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("1.2/3"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("."))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("/"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("2/"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkInteger(("/2"))); + + int val1 = 1; + long val2 = -1; + int val3 = 1; + long val4 = -1; + assertDoesNotThrow(() -> d_solver.mkInteger(val1)); + assertDoesNotThrow(() -> d_solver.mkInteger(val2)); + assertDoesNotThrow(() -> d_solver.mkInteger(val3)); + assertDoesNotThrow(() -> d_solver.mkInteger(val4)); + assertDoesNotThrow(() -> d_solver.mkInteger(val4)); + } + + @Test void mkReal() + { + assertDoesNotThrow(() -> d_solver.mkReal("123")); + assertDoesNotThrow(() -> d_solver.mkReal("1.23")); + assertDoesNotThrow(() -> d_solver.mkReal("1/23")); + assertDoesNotThrow(() -> d_solver.mkReal("12/3")); + assertDoesNotThrow(() -> d_solver.mkReal(".2")); + assertDoesNotThrow(() -> d_solver.mkReal("2.")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal("")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal("asdf")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal("1.2/3")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(".")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal("/")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal("2/")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal("/2")); + + assertDoesNotThrow(() -> d_solver.mkReal(("123"))); + assertDoesNotThrow(() -> d_solver.mkReal(("1.23"))); + assertDoesNotThrow(() -> d_solver.mkReal(("1/23"))); + assertDoesNotThrow(() -> d_solver.mkReal(("12/3"))); + assertDoesNotThrow(() -> d_solver.mkReal((".2"))); + assertDoesNotThrow(() -> d_solver.mkReal(("2."))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal((""))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(("asdf"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(("1.2/3"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(("."))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(("/"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(("2/"))); + assertThrows(CVC5ApiException.class, () -> d_solver.mkReal(("/2"))); + + int val1 = 1; + long val2 = -1; + int val3 = 1; + long val4 = -1; + assertDoesNotThrow(() -> d_solver.mkReal(val1)); + assertDoesNotThrow(() -> d_solver.mkReal(val2)); + assertDoesNotThrow(() -> d_solver.mkReal(val3)); + assertDoesNotThrow(() -> d_solver.mkReal(val4)); + assertDoesNotThrow(() -> d_solver.mkReal(val4)); + assertDoesNotThrow(() -> d_solver.mkReal(val1, val1)); + assertDoesNotThrow(() -> d_solver.mkReal(val2, val2)); + assertDoesNotThrow(() -> d_solver.mkReal(val3, val3)); + assertDoesNotThrow(() -> d_solver.mkReal(val4, val4)); + } + + @Test void mkRegexpEmpty() + { + Sort strSort = d_solver.getStringSort(); + Term s = d_solver.mkConst(strSort, "s"); + assertDoesNotThrow(() -> d_solver.mkTerm(STRING_IN_REGEXP, s, d_solver.mkRegexpEmpty())); + } + + @Test void mkRegexpSigma() + { + Sort strSort = d_solver.getStringSort(); + Term s = d_solver.mkConst(strSort, "s"); + assertDoesNotThrow(() -> d_solver.mkTerm(STRING_IN_REGEXP, s, d_solver.mkRegexpSigma())); + } + + @Test void mkSepNil() + { + assertDoesNotThrow(() -> d_solver.mkSepNil(d_solver.getBooleanSort())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkSepNil(d_solver.getNullSort())); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkSepNil(d_solver.getIntegerSort())); + } + + @Test void mkString() + { + assertDoesNotThrow(() -> d_solver.mkString("")); + assertDoesNotThrow(() -> d_solver.mkString("asdfasdf")); + assertEquals(d_solver.mkString("asdf\\nasdf").toString(), "\"asdf\\u{5c}nasdf\""); + assertEquals(d_solver.mkString("asdf\\u{005c}nasdf", true).toString(), "\"asdf\\u{5c}nasdf\""); + } + + @Test void mkTerm() throws CVC5ApiException + { + Sort bv32 = d_solver.mkBitVectorSort(32); + Term a = d_solver.mkConst(bv32, "a"); + Term b = d_solver.mkConst(bv32, "b"); + Term[] v1 = new Term[] {a, b}; + Term[] v2 = new Term[] {a, d_solver.getNullTerm()}; + Term[] v3 = new Term[] {a, d_solver.mkTrue()}; + Term[] v4 = new Term[] {d_solver.mkInteger(1), d_solver.mkInteger(2)}; + Term[] v5 = new Term[] {d_solver.mkInteger(1), d_solver.getNullTerm()}; + Term[] v6 = new Term[] {}; + Solver slv = new Solver(); + + // mkTerm(Kind kind) const + assertDoesNotThrow(() -> d_solver.mkTerm(PI)); + assertDoesNotThrow(() -> d_solver.mkTerm(REGEXP_EMPTY)); + assertDoesNotThrow(() -> d_solver.mkTerm(REGEXP_SIGMA)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(CONST_BITVECTOR)); + + // mkTerm(Kind kind, Term child) const + assertDoesNotThrow(() -> d_solver.mkTerm(NOT, d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(NOT, d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(NOT, a)); + assertThrows(CVC5ApiException.class, () -> slv.mkTerm(NOT, d_solver.mkTrue())); + + // mkTerm(Kind kind, Term child1, Term child2) const + assertDoesNotThrow(() -> d_solver.mkTerm(EQUAL, a, b)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(EQUAL, d_solver.getNullTerm(), b)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(EQUAL, a, d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(EQUAL, a, d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> slv.mkTerm(EQUAL, a, b)); + + // mkTerm(Kind kind, Term child1, Term child2, Term child3) const + assertDoesNotThrow( + () -> d_solver.mkTerm(ITE, d_solver.mkTrue(), d_solver.mkTrue(), d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(ITE, d_solver.getNullTerm(), d_solver.mkTrue(), d_solver.mkTrue())); + + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(ITE, d_solver.mkTrue(), d_solver.getNullTerm(), d_solver.mkTrue())); + + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(ITE, d_solver.mkTrue(), d_solver.mkTrue(), d_solver.getNullTerm())); + + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(ITE, d_solver.mkTrue(), d_solver.mkTrue(), b)); + + assertThrows(CVC5ApiException.class, + () -> slv.mkTerm(ITE, d_solver.mkTrue(), d_solver.mkTrue(), d_solver.mkTrue())); + + // mkTerm(Kind kind, const Term[]& children) const + assertDoesNotThrow(() -> d_solver.mkTerm(EQUAL, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(EQUAL, v2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(EQUAL, v3)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(DISTINCT, v6)); + } + + @Test void mkTermFromOp() throws CVC5ApiException + { + Sort bv32 = d_solver.mkBitVectorSort(32); + Term a = d_solver.mkConst(bv32, "a"); + Term b = d_solver.mkConst(bv32, "b"); + Term[] v1 = new Term[] {d_solver.mkInteger(1), d_solver.mkInteger(2)}; + Term[] v2 = new Term[] {d_solver.mkInteger(1), d_solver.getNullTerm()}; + Term[] v3 = new Term[] {}; + Term[] v4 = new Term[] {d_solver.mkInteger(5)}; + Solver slv = new Solver(); + + // simple operator terms + Op opterm1 = d_solver.mkOp(BITVECTOR_EXTRACT, 2, 1); + Op opterm2 = d_solver.mkOp(DIVISIBLE, 1); + + // list datatype + Sort sort = d_solver.mkParamSort("T"); + DatatypeDecl listDecl = d_solver.mkDatatypeDecl("paramlist", sort); + DatatypeConstructorDecl cons = d_solver.mkDatatypeConstructorDecl("cons"); + DatatypeConstructorDecl nil = d_solver.mkDatatypeConstructorDecl("nil"); + cons.addSelector("head", sort); + cons.addSelectorSelf("tail"); + listDecl.addConstructor(cons); + listDecl.addConstructor(nil); + Sort listSort = d_solver.mkDatatypeSort(listDecl); + Sort intListSort = listSort.instantiate(new Sort[] {d_solver.getIntegerSort()}); + Term c = d_solver.mkConst(intListSort, "c"); + Datatype list = listSort.getDatatype(); + + // list datatype constructor and selector operator terms + Term consTerm1 = list.getConstructorTerm("cons"); + Term consTerm2 = list.getConstructor("cons").getConstructorTerm(); + Term nilTerm1 = list.getConstructorTerm("nil"); + Term nilTerm2 = list.getConstructor("nil").getConstructorTerm(); + Term headTerm1 = list.getConstructor("cons").getSelectorTerm("head"); + Term headTerm2 = list.getConstructor("cons").getSelector("head").getSelectorTerm(); + Term tailTerm1 = list.getConstructor("cons").getSelectorTerm("tail"); + Term tailTerm2 = list.getConstructor("cons").getSelector("tail").getSelectorTerm(); + + // mkTerm(Op op, Term term) const + assertDoesNotThrow(() -> d_solver.mkTerm(APPLY_CONSTRUCTOR, nilTerm1)); + assertDoesNotThrow(() -> d_solver.mkTerm(APPLY_CONSTRUCTOR, nilTerm2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(APPLY_SELECTOR, nilTerm1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(APPLY_SELECTOR, consTerm1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(APPLY_CONSTRUCTOR, consTerm2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(APPLY_SELECTOR, headTerm1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm1)); + assertThrows(CVC5ApiException.class, () -> slv.mkTerm(APPLY_CONSTRUCTOR, nilTerm1)); + + // mkTerm(Op op, Term child) const + assertDoesNotThrow(() -> d_solver.mkTerm(opterm1, a)); + assertDoesNotThrow(() -> d_solver.mkTerm(opterm2, d_solver.mkInteger(1))); + assertDoesNotThrow(() -> d_solver.mkTerm(APPLY_SELECTOR, headTerm1, c)); + assertDoesNotThrow(() -> d_solver.mkTerm(APPLY_SELECTOR, tailTerm2, c)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm2, a)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm1, d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(APPLY_CONSTRUCTOR, consTerm1, d_solver.mkInteger(0))); + + assertThrows(CVC5ApiException.class, () -> slv.mkTerm(opterm1, a)); + + // mkTerm(Op op, Term child1, Term child2) const + assertDoesNotThrow(() + -> d_solver.mkTerm(APPLY_CONSTRUCTOR, + consTerm1, + d_solver.mkInteger(0), + d_solver.mkTerm(APPLY_CONSTRUCTOR, nilTerm1))); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(opterm2, d_solver.mkInteger(1), d_solver.mkInteger(2))); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm1, a, b)); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(opterm2, d_solver.mkInteger(1), d_solver.getNullTerm())); + + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(opterm2, d_solver.getNullTerm(), d_solver.mkInteger(1))); + + assertThrows(CVC5ApiException.class, + () + -> slv.mkTerm(APPLY_CONSTRUCTOR, + consTerm1, + d_solver.mkInteger(0), + d_solver.mkTerm(APPLY_CONSTRUCTOR, nilTerm1))); + + // mkTerm(Op op, Term child1, Term child2, Term child3) const + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm1, a, b, a)); + assertThrows(CVC5ApiException.class, + () + -> d_solver.mkTerm( + opterm2, d_solver.mkInteger(1), d_solver.mkInteger(1), d_solver.getNullTerm())); + + // mkTerm(Op op, Term[] children) + assertDoesNotThrow(() -> d_solver.mkTerm(opterm2, v4)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm2, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm2, v2)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkTerm(opterm2, v3)); + assertThrows(CVC5ApiException.class, () -> slv.mkTerm(opterm2, v4)); + } + + @Test void mkTrue() + { + assertDoesNotThrow(() -> d_solver.mkTrue()); + assertDoesNotThrow(() -> d_solver.mkTrue()); + } + + @Test void mkTuple() + { + assertDoesNotThrow(() + -> d_solver.mkTuple(new Sort[] {d_solver.mkBitVectorSort(3)}, + new Term[] {d_solver.mkBitVector(3, "101", 2)})); + assertDoesNotThrow(() + -> d_solver.mkTuple(new Sort[] {d_solver.getRealSort()}, + new Term[] {d_solver.mkInteger("5")})); + + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTuple(new Sort[] {}, new Term[] {d_solver.mkBitVector(3, "101", 2)})); + + assertThrows(CVC5ApiException.class, + () + -> d_solver.mkTuple(new Sort[] {d_solver.mkBitVectorSort(4)}, + new Term[] {d_solver.mkBitVector(3, "101", 2)})); + + assertThrows(CVC5ApiException.class, + () + -> d_solver.mkTuple( + new Sort[] {d_solver.getIntegerSort()}, new Term[] {d_solver.mkReal("5.3")})); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, + () + -> slv.mkTuple(new Sort[] {d_solver.mkBitVectorSort(3)}, + new Term[] {slv.mkBitVector(3, "101", 2)})); + + assertThrows(CVC5ApiException.class, + () + -> slv.mkTuple(new Sort[] {slv.mkBitVectorSort(3)}, + new Term[] {d_solver.mkBitVector(3, "101", 2)})); + } + + @Test void mkUniverseSet() + { + assertDoesNotThrow(() -> d_solver.mkUniverseSet(d_solver.getBooleanSort())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkUniverseSet(d_solver.getNullSort())); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkUniverseSet(d_solver.getBooleanSort())); + } + + @Test void mkConst() + { + Sort boolSort = d_solver.getBooleanSort(); + Sort intSort = d_solver.getIntegerSort(); + Sort funSort = d_solver.mkFunctionSort(intSort, boolSort); + assertDoesNotThrow(() -> d_solver.mkConst(boolSort)); + assertDoesNotThrow(() -> d_solver.mkConst(funSort)); + assertDoesNotThrow(() -> d_solver.mkConst(boolSort, ("b"))); + assertDoesNotThrow(() -> d_solver.mkConst(intSort, ("i"))); + assertDoesNotThrow(() -> d_solver.mkConst(funSort, "f")); + assertDoesNotThrow(() -> d_solver.mkConst(funSort, "")); + assertThrows(CVC5ApiException.class, () -> d_solver.mkConst(d_solver.getNullSort())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkConst(d_solver.getNullSort(), "a")); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkConst(boolSort)); + } + + @Test void mkConstArray() + { + Sort intSort = d_solver.getIntegerSort(); + Sort arrSort = d_solver.mkArraySort(intSort, intSort); + Term zero = d_solver.mkInteger(0); + Term constArr = d_solver.mkConstArray(arrSort, zero); + + assertDoesNotThrow(() -> d_solver.mkConstArray(arrSort, zero)); + assertThrows(CVC5ApiException.class, () -> d_solver.mkConstArray(d_solver.getNullSort(), zero)); + assertThrows( + CVC5ApiException.class, () -> d_solver.mkConstArray(arrSort, d_solver.getNullTerm())); + assertThrows( + CVC5ApiException.class, () -> d_solver.mkConstArray(arrSort, d_solver.mkBitVector(1, 1))); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkConstArray(intSort, zero)); + Solver slv = new Solver(); + Term zero2 = slv.mkInteger(0); + Sort arrSort2 = slv.mkArraySort(slv.getIntegerSort(), slv.getIntegerSort()); + assertThrows(CVC5ApiException.class, () -> slv.mkConstArray(arrSort2, zero)); + assertThrows(CVC5ApiException.class, () -> slv.mkConstArray(arrSort, zero2)); + } + + @Test void declareDatatype() + { + DatatypeConstructorDecl nil = d_solver.mkDatatypeConstructorDecl("nil"); + DatatypeConstructorDecl[] ctors1 = new DatatypeConstructorDecl[] {nil}; + assertDoesNotThrow(() -> d_solver.declareDatatype(("a"), ctors1)); + DatatypeConstructorDecl cons = d_solver.mkDatatypeConstructorDecl("cons"); + DatatypeConstructorDecl nil2 = d_solver.mkDatatypeConstructorDecl("nil"); + DatatypeConstructorDecl[] ctors2 = new DatatypeConstructorDecl[] {cons, nil2}; + assertDoesNotThrow(() -> d_solver.declareDatatype(("b"), ctors2)); + DatatypeConstructorDecl cons2 = d_solver.mkDatatypeConstructorDecl("cons"); + DatatypeConstructorDecl nil3 = d_solver.mkDatatypeConstructorDecl("nil"); + DatatypeConstructorDecl[] ctors3 = new DatatypeConstructorDecl[] {cons2, nil3}; + assertDoesNotThrow(() -> d_solver.declareDatatype((""), ctors3)); + DatatypeConstructorDecl[] ctors4 = new DatatypeConstructorDecl[0]; + assertThrows(CVC5ApiException.class, () -> d_solver.declareDatatype(("c"), ctors4)); + + assertThrows(CVC5ApiException.class, () -> d_solver.declareDatatype((""), ctors4)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.declareDatatype(("a"), ctors1)); + } + + @Test void declareFun() throws CVC5ApiException + { + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort funSort = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + assertDoesNotThrow(() -> d_solver.declareFun("f1", new Sort[] {}, bvSort)); + assertDoesNotThrow( + () -> d_solver.declareFun("f3", new Sort[] {bvSort, d_solver.getIntegerSort()}, bvSort)); + assertThrows(CVC5ApiException.class, () -> d_solver.declareFun("f2", new Sort[] {}, funSort)); + // functions as arguments is allowed + assertDoesNotThrow(() -> d_solver.declareFun("f4", new Sort[] {bvSort, funSort}, bvSort)); + assertThrows(CVC5ApiException.class, + () -> d_solver.declareFun("f5", new Sort[] {bvSort, bvSort}, funSort)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.declareFun("f1", new Sort[] {}, bvSort)); + } + + @Test void declareSort() + { + assertDoesNotThrow(() -> d_solver.declareSort("s", 0)); + assertDoesNotThrow(() -> d_solver.declareSort("s", 2)); + assertDoesNotThrow(() -> d_solver.declareSort("", 2)); + } + + @Test void defineSort() + { + Sort sortVar0 = d_solver.mkParamSort("T0"); + Sort sortVar1 = d_solver.mkParamSort("T1"); + Sort intSort = d_solver.getIntegerSort(); + Sort realSort = d_solver.getRealSort(); + Sort arraySort0 = d_solver.mkArraySort(sortVar0, sortVar0); + Sort arraySort1 = d_solver.mkArraySort(sortVar0, sortVar1); + // Now create instantiations of the defined sorts + assertDoesNotThrow(() -> arraySort0.substitute(sortVar0, intSort)); + assertDoesNotThrow(() + -> arraySort1.substitute( + new Sort[] {sortVar0, sortVar1}, new Sort[] {intSort, realSort})); + } + + @Test void defineFun() throws CVC5ApiException + { + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort funSort1 = d_solver.mkFunctionSort(new Sort[] {bvSort, bvSort}, bvSort); + Sort funSort2 = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + Term b1 = d_solver.mkVar(bvSort, "b1"); + Term b11 = d_solver.mkVar(bvSort, "b1"); + Term b2 = d_solver.mkVar(d_solver.getIntegerSort(), "b2"); + Term b3 = d_solver.mkVar(funSort2, "b3"); + Term v1 = d_solver.mkConst(bvSort, "v1"); + Term v2 = d_solver.mkConst(d_solver.getIntegerSort(), "v2"); + Term v3 = d_solver.mkConst(funSort2, "v3"); + Term f1 = d_solver.mkConst(funSort1, "f1"); + Term f2 = d_solver.mkConst(funSort2, "f2"); + Term f3 = d_solver.mkConst(bvSort, "f3"); + assertDoesNotThrow(() -> d_solver.defineFun("f", new Term[] {}, bvSort, v1)); + assertDoesNotThrow(() -> d_solver.defineFun("ff", new Term[] {b1, b2}, bvSort, v1)); + assertDoesNotThrow(() -> d_solver.defineFun(f1, new Term[] {b1, b11}, v1)); + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFun("ff", new Term[] {v1, b2}, bvSort, v1)); + + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFun("fff", new Term[] {b1}, bvSort, v3)); + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFun("ffff", new Term[] {b1}, funSort2, v3)); + + // b3 has function sort, which is allowed as an argument + assertDoesNotThrow(() -> d_solver.defineFun("fffff", new Term[] {b1, b3}, bvSort, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFun(f1, new Term[] {v1, b11}, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFun(f1, new Term[] {b1}, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFun(f1, new Term[] {b1, b11}, v2)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFun(f1, new Term[] {b1, b11}, v3)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFun(f2, new Term[] {b1}, v2)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFun(f3, new Term[] {b1}, v1)); + + Solver slv = new Solver(); + Sort bvSort2 = slv.mkBitVectorSort(32); + Term v12 = slv.mkConst(bvSort2, "v1"); + Term b12 = slv.mkVar(bvSort2, "b1"); + Term b22 = slv.mkVar(slv.getIntegerSort(), "b2"); + assertThrows(CVC5ApiException.class, () -> slv.defineFun("f", new Term[] {}, bvSort, v12)); + assertThrows(CVC5ApiException.class, () -> slv.defineFun("f", new Term[] {}, bvSort2, v1)); + assertThrows( + CVC5ApiException.class, () -> slv.defineFun("ff", new Term[] {b1, b22}, bvSort2, v12)); + assertThrows( + CVC5ApiException.class, () -> slv.defineFun("ff", new Term[] {b12, b2}, bvSort2, v12)); + assertThrows( + CVC5ApiException.class, () -> slv.defineFun("ff", new Term[] {b12, b22}, bvSort, v12)); + assertThrows( + CVC5ApiException.class, () -> slv.defineFun("ff", new Term[] {b12, b22}, bvSort2, v1)); + } + + @Test void defineFunGlobal() + { + Sort bSort = d_solver.getBooleanSort(); + Sort fSort = d_solver.mkFunctionSort(bSort, bSort); + + Term bTrue = d_solver.mkBoolean(true); + // (define-fun f () Bool true) + Term f = d_solver.defineFun("f", new Term[] {}, bSort, bTrue, true); + Term b = d_solver.mkVar(bSort, "b"); + Term gSym = d_solver.mkConst(fSort, "g"); + // (define-fun g (b Bool) Bool b) + Term g = d_solver.defineFun(gSym, new Term[] {b}, b, true); + + // (assert (or (not f) (not (g true)))) + d_solver.assertFormula( + d_solver.mkTerm(OR, f.notTerm(), d_solver.mkTerm(APPLY_UF, g, bTrue).notTerm())); + assertTrue(d_solver.checkSat().isUnsat()); + d_solver.resetAssertions(); + // (assert (or (not f) (not (g true)))) + d_solver.assertFormula( + d_solver.mkTerm(OR, f.notTerm(), d_solver.mkTerm(APPLY_UF, g, bTrue).notTerm())); + assertTrue(d_solver.checkSat().isUnsat()); + } + + @Test void defineFunRec() throws CVC5ApiException + { + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort funSort1 = d_solver.mkFunctionSort(new Sort[] {bvSort, bvSort}, bvSort); + Sort funSort2 = + d_solver.mkFunctionSort(d_solver.mkUninterpretedSort("u"), d_solver.getIntegerSort()); + Term b1 = d_solver.mkVar(bvSort, "b1"); + Term b11 = d_solver.mkVar(bvSort, "b1"); + Term b2 = d_solver.mkVar(d_solver.getIntegerSort(), "b2"); + Term b3 = d_solver.mkVar(funSort2, "b3"); + Term v1 = d_solver.mkConst(bvSort, "v1"); + Term v2 = d_solver.mkConst(d_solver.getIntegerSort(), "v2"); + Term v3 = d_solver.mkConst(funSort2, "v3"); + Term f1 = d_solver.mkConst(funSort1, "f1"); + Term f2 = d_solver.mkConst(funSort2, "f2"); + Term f3 = d_solver.mkConst(bvSort, "f3"); + assertDoesNotThrow(() -> d_solver.defineFunRec("f", new Term[] {}, bvSort, v1)); + assertDoesNotThrow(() -> d_solver.defineFunRec("ff", new Term[] {b1, b2}, bvSort, v1)); + assertDoesNotThrow(() -> d_solver.defineFunRec(f1, new Term[] {b1, b11}, v1)); + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFunRec("fff", new Term[] {b1}, bvSort, v3)); + + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFunRec("ff", new Term[] {b1, v2}, bvSort, v1)); + + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFunRec("ffff", new Term[] {b1}, funSort2, v3)); + + // b3 has function sort, which is allowed as an argument + assertDoesNotThrow(() -> d_solver.defineFunRec("fffff", new Term[] {b1, b3}, bvSort, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFunRec(f1, new Term[] {b1}, v1)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFunRec(f1, new Term[] {b1, b11}, v2)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFunRec(f1, new Term[] {b1, b11}, v3)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFunRec(f2, new Term[] {b1}, v2)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFunRec(f3, new Term[] {b1}, v1)); + + Solver slv = new Solver(); + Sort bvSort2 = slv.mkBitVectorSort(32); + Term v12 = slv.mkConst(bvSort2, "v1"); + Term b12 = slv.mkVar(bvSort2, "b1"); + Term b22 = slv.mkVar(slv.getIntegerSort(), "b2"); + assertDoesNotThrow(() -> slv.defineFunRec("f", new Term[] {}, bvSort2, v12)); + assertDoesNotThrow(() -> slv.defineFunRec("ff", new Term[] {b12, b22}, bvSort2, v12)); + assertThrows(CVC5ApiException.class, () -> slv.defineFunRec("f", new Term[] {}, bvSort, v12)); + assertThrows(CVC5ApiException.class, () -> slv.defineFunRec("f", new Term[] {}, bvSort2, v1)); + assertThrows( + CVC5ApiException.class, () -> slv.defineFunRec("ff", new Term[] {b1, b22}, bvSort2, v12)); + + assertThrows( + CVC5ApiException.class, () -> slv.defineFunRec("ff", new Term[] {b12, b2}, bvSort2, v12)); + + assertThrows( + CVC5ApiException.class, () -> slv.defineFunRec("ff", new Term[] {b12, b22}, bvSort, v12)); + + assertThrows( + CVC5ApiException.class, () -> slv.defineFunRec("ff", new Term[] {b12, b22}, bvSort2, v1)); + } + + @Test void defineFunRecWrongLogic() throws CVC5ApiException + { + d_solver.setLogic("QF_BV"); + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort funSort = d_solver.mkFunctionSort(new Sort[] {bvSort, bvSort}, bvSort); + Term b = d_solver.mkVar(bvSort, "b"); + Term v = d_solver.mkConst(bvSort, "v"); + Term f = d_solver.mkConst(funSort, "f"); + assertThrows( + CVC5ApiException.class, () -> d_solver.defineFunRec("f", new Term[] {}, bvSort, v)); + assertThrows(CVC5ApiException.class, () -> d_solver.defineFunRec(f, new Term[] {b, b}, v)); + } + + @Test void defineFunRecGlobal() throws CVC5ApiException + { + Sort bSort = d_solver.getBooleanSort(); + Sort fSort = d_solver.mkFunctionSort(bSort, bSort); + + d_solver.push(); + Term bTrue = d_solver.mkBoolean(true); + // (define-fun f () Bool true) + Term f = d_solver.defineFunRec("f", new Term[] {}, bSort, bTrue, true); + Term b = d_solver.mkVar(bSort, "b"); + Term gSym = d_solver.mkConst(fSort, "g"); + // (define-fun g (b Bool) Bool b) + Term g = d_solver.defineFunRec(gSym, new Term[] {b}, b, true); + + // (assert (or (not f) (not (g true)))) + d_solver.assertFormula( + d_solver.mkTerm(OR, f.notTerm(), d_solver.mkTerm(APPLY_UF, g, bTrue).notTerm())); + assertTrue(d_solver.checkSat().isUnsat()); + d_solver.pop(); + // (assert (or (not f) (not (g true)))) + d_solver.assertFormula( + d_solver.mkTerm(OR, f.notTerm(), d_solver.mkTerm(APPLY_UF, g, bTrue).notTerm())); + assertTrue(d_solver.checkSat().isUnsat()); + } + + @Test void defineFunsRec() throws CVC5ApiException + { + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort funSort1 = d_solver.mkFunctionSort(new Sort[] {bvSort, bvSort}, bvSort); + Sort funSort2 = d_solver.mkFunctionSort(uSort, d_solver.getIntegerSort()); + Term b1 = d_solver.mkVar(bvSort, "b1"); + Term b11 = d_solver.mkVar(bvSort, "b1"); + Term b2 = d_solver.mkVar(d_solver.getIntegerSort(), "b2"); + Term b3 = d_solver.mkVar(funSort2, "b3"); + Term b4 = d_solver.mkVar(uSort, "b4"); + Term v1 = d_solver.mkConst(bvSort, "v1"); + Term v2 = d_solver.mkConst(d_solver.getIntegerSort(), "v2"); + Term v3 = d_solver.mkConst(funSort2, "v3"); + Term v4 = d_solver.mkConst(uSort, "v4"); + Term f1 = d_solver.mkConst(funSort1, "f1"); + Term f2 = d_solver.mkConst(funSort2, "f2"); + Term f3 = d_solver.mkConst(bvSort, "f3"); + assertDoesNotThrow( + () + -> d_solver.defineFunsRec( + new Term[] {f1, f2}, new Term[][] {{b1, b11}, {b4}}, new Term[] {v1, v2})); + assertThrows(CVC5ApiException.class, + () + -> d_solver.defineFunsRec( + new Term[] {f1, f2}, new Term[][] {{v1, b11}, {b4}}, new Term[] {v1, v2})); + assertThrows(CVC5ApiException.class, + () + -> d_solver.defineFunsRec( + new Term[] {f1, f3}, new Term[][] {{b1, b11}, {b4}}, new Term[] {v1, v2})); + assertThrows(CVC5ApiException.class, + () + -> d_solver.defineFunsRec( + new Term[] {f1, f2}, new Term[][] {{b1}, {b4}}, new Term[] {v1, v2})); + assertThrows(CVC5ApiException.class, + () + -> d_solver.defineFunsRec( + new Term[] {f1, f2}, new Term[][] {{b1, b2}, {b4}}, new Term[] {v1, v2})); + assertThrows(CVC5ApiException.class, + () + -> d_solver.defineFunsRec( + new Term[] {f1, f2}, new Term[][] {{b1, b11}, {b4}}, new Term[] {v1, v4})); + + Solver slv = new Solver(); + Sort uSort2 = slv.mkUninterpretedSort("u"); + Sort bvSort2 = slv.mkBitVectorSort(32); + Sort funSort12 = slv.mkFunctionSort(new Sort[] {bvSort2, bvSort2}, bvSort2); + Sort funSort22 = slv.mkFunctionSort(uSort2, slv.getIntegerSort()); + Term b12 = slv.mkVar(bvSort2, "b1"); + Term b112 = slv.mkVar(bvSort2, "b1"); + Term b42 = slv.mkVar(uSort2, "b4"); + Term v12 = slv.mkConst(bvSort2, "v1"); + Term v22 = slv.mkConst(slv.getIntegerSort(), "v2"); + Term f12 = slv.mkConst(funSort12, "f1"); + Term f22 = slv.mkConst(funSort22, "f2"); + assertDoesNotThrow( + () + -> slv.defineFunsRec( + new Term[] {f12, f22}, new Term[][] {{b12, b112}, {b42}}, new Term[] {v12, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f1, f22}, new Term[][] {{b12, b112}, {b42}}, new Term[] {v12, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f12, f2}, new Term[][] {{b12, b112}, {b42}}, new Term[] {v12, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f12, f22}, new Term[][] {{b1, b112}, {b42}}, new Term[] {v12, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f12, f22}, new Term[][] {{b12, b11}, {b42}}, new Term[] {v12, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f12, f22}, new Term[][] {{b12, b112}, {b4}}, new Term[] {v12, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f12, f22}, new Term[][] {{b12, b112}, {b42}}, new Term[] {v1, v22})); + assertThrows(CVC5ApiException.class, + () + -> slv.defineFunsRec( + new Term[] {f12, f22}, new Term[][] {{b12, b112}, {b42}}, new Term[] {v12, v2})); + } + + @Test void defineFunsRecWrongLogic() throws CVC5ApiException + { + d_solver.setLogic("QF_BV"); + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort funSort1 = d_solver.mkFunctionSort(new Sort[] {bvSort, bvSort}, bvSort); + Sort funSort2 = d_solver.mkFunctionSort(uSort, d_solver.getIntegerSort()); + Term b = d_solver.mkVar(bvSort, "b"); + Term u = d_solver.mkVar(uSort, "u"); + Term v1 = d_solver.mkConst(bvSort, "v1"); + Term v2 = d_solver.mkConst(d_solver.getIntegerSort(), "v2"); + Term f1 = d_solver.mkConst(funSort1, "f1"); + Term f2 = d_solver.mkConst(funSort2, "f2"); + assertThrows(CVC5ApiException.class, + () + -> d_solver.defineFunsRec( + new Term[] {f1, f2}, new Term[][] {{b, b}, {u}}, new Term[] {v1, v2})); + } + + @Test void defineFunsRecGlobal() throws CVC5ApiException + { + Sort bSort = d_solver.getBooleanSort(); + Sort fSort = d_solver.mkFunctionSort(bSort, bSort); + + d_solver.push(); + Term bTrue = d_solver.mkBoolean(true); + Term b = d_solver.mkVar(bSort, "b"); + Term gSym = d_solver.mkConst(fSort, "g"); + // (define-funs-rec ((g ((b Bool)) Bool)) (b)) + d_solver.defineFunsRec(new Term[] {gSym}, new Term[][] {{b}}, new Term[] {b}, true); + + // (assert (not (g true))) + d_solver.assertFormula(d_solver.mkTerm(APPLY_UF, gSym, bTrue).notTerm()); + assertTrue(d_solver.checkSat().isUnsat()); + d_solver.pop(); + // (assert (not (g true))) + d_solver.assertFormula(d_solver.mkTerm(APPLY_UF, gSym, bTrue).notTerm()); + assertTrue(d_solver.checkSat().isUnsat()); + } + + @Test void uFIteration() + { + Sort intSort = d_solver.getIntegerSort(); + Sort funSort = d_solver.mkFunctionSort(new Sort[] {intSort, intSort}, intSort); + Term x = d_solver.mkConst(intSort, "x"); + Term y = d_solver.mkConst(intSort, "y"); + Term f = d_solver.mkConst(funSort, "f"); + Term fxy = d_solver.mkTerm(APPLY_UF, f, x, y); + + // Expecting the uninterpreted function to be one of the children + Term expected_children[] = new Term[] {f, x, y}; + int idx = 0; + for (Term c : fxy) + { + assertEquals(c, expected_children[idx]); + idx++; + } + } + + @Test void getInfo() + { + assertDoesNotThrow(() -> d_solver.getInfo("name")); + assertThrows(CVC5ApiException.class, () -> d_solver.getInfo("asdf")); + } + + @Test void getInterpolant() throws CVC5ApiException + { + d_solver.setLogic("QF_LIA"); + d_solver.setOption("produce-interpols", "default"); + d_solver.setOption("incremental", "false"); + + Sort intSort = d_solver.getIntegerSort(); + Term zero = d_solver.mkInteger(0); + Term x = d_solver.mkConst(intSort, "x"); + Term y = d_solver.mkConst(intSort, "y"); + Term z = d_solver.mkConst(intSort, "z"); + + // Assumptions for interpolation: x + y > 0 /\ x < 0 + d_solver.assertFormula(d_solver.mkTerm(GT, d_solver.mkTerm(PLUS, x, y), zero)); + d_solver.assertFormula(d_solver.mkTerm(LT, x, zero)); + // Conjecture for interpolation: y + z > 0 \/ z < 0 + Term conj = d_solver.mkTerm( + OR, d_solver.mkTerm(GT, d_solver.mkTerm(PLUS, y, z), zero), d_solver.mkTerm(LT, z, zero)); + Term output = d_solver.getNullTerm(); + // Call the interpolation api, while the resulting interpolant is the output + d_solver.getInterpolant(conj, output); + + // We expect the resulting output to be a boolean formula + assertTrue(output.getSort().isBoolean()); + } + + @Test void getOp() throws CVC5ApiException + { + Sort bv32 = d_solver.mkBitVectorSort(32); + Term a = d_solver.mkConst(bv32, "a"); + Op ext = d_solver.mkOp(BITVECTOR_EXTRACT, 2, 1); + Term exta = d_solver.mkTerm(ext, a); + + assertFalse(a.hasOp()); + assertThrows(CVC5ApiException.class, () -> a.getOp()); + assertTrue(exta.hasOp()); + assertEquals(exta.getOp(), ext); + + // Test Datatypes -- more complicated + DatatypeDecl consListSpec = d_solver.mkDatatypeDecl("list"); + DatatypeConstructorDecl cons = d_solver.mkDatatypeConstructorDecl("cons"); + cons.addSelector("head", d_solver.getIntegerSort()); + cons.addSelectorSelf("tail"); + consListSpec.addConstructor(cons); + DatatypeConstructorDecl nil = d_solver.mkDatatypeConstructorDecl("nil"); + consListSpec.addConstructor(nil); + Sort consListSort = d_solver.mkDatatypeSort(consListSpec); + Datatype consList = consListSort.getDatatype(); + + Term consTerm = consList.getConstructorTerm("cons"); + Term nilTerm = consList.getConstructorTerm("nil"); + Term headTerm = consList.getConstructor("cons").getSelectorTerm("head"); + + Term listnil = d_solver.mkTerm(APPLY_CONSTRUCTOR, nilTerm); + Term listcons1 = d_solver.mkTerm(APPLY_CONSTRUCTOR, consTerm, d_solver.mkInteger(1), listnil); + Term listhead = d_solver.mkTerm(APPLY_SELECTOR, headTerm, listcons1); + + assertTrue(listnil.hasOp()); + assertTrue(listcons1.hasOp()); + assertTrue(listhead.hasOp()); + } + + @Test void getOption() + { + assertDoesNotThrow(() -> d_solver.getOption("incremental")); + assertThrows(CVC5ApiException.class, () -> d_solver.getOption("asdf")); + } + + @Test void getUnsatAssumptions1() + { + d_solver.setOption("incremental", "false"); + d_solver.checkSatAssuming(d_solver.mkFalse()); + assertThrows(CVC5ApiException.class, () -> d_solver.getUnsatAssumptions()); + } + + @Test void getUnsatAssumptions2() + { + d_solver.setOption("incremental", "true"); + d_solver.setOption("produce-unsat-assumptions", "false"); + d_solver.checkSatAssuming(d_solver.mkFalse()); + assertThrows(CVC5ApiException.class, () -> d_solver.getUnsatAssumptions()); + } + + @Test void getUnsatAssumptions3() { - d_solver.deletePointer(); + d_solver.setOption("incremental", "true"); + d_solver.setOption("produce-unsat-assumptions", "true"); + d_solver.checkSatAssuming(d_solver.mkFalse()); + assertDoesNotThrow(() -> d_solver.getUnsatAssumptions()); + d_solver.checkSatAssuming(d_solver.mkTrue()); + assertThrows(CVC5ApiException.class, () -> d_solver.getUnsatAssumptions()); } - @Test void setLogic() + @Test void getUnsatCore1() + { + d_solver.setOption("incremental", "false"); + d_solver.assertFormula(d_solver.mkFalse()); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getUnsatCore()); + } + + @Test void getUnsatCore2() + { + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-unsat-cores", "false"); + d_solver.assertFormula(d_solver.mkFalse()); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getUnsatCore()); + } + + @Test void getUnsatCore3() + { + d_solver.setOption("incremental", "true"); + d_solver.setOption("produce-unsat-cores", "true"); + + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort intSort = d_solver.getIntegerSort(); + Sort boolSort = d_solver.getBooleanSort(); + Sort uToIntSort = d_solver.mkFunctionSort(uSort, intSort); + Sort intPredSort = d_solver.mkFunctionSort(intSort, boolSort); + Term[] unsat_core; + + Term x = d_solver.mkConst(uSort, "x"); + Term y = d_solver.mkConst(uSort, "y"); + Term f = d_solver.mkConst(uToIntSort, "f"); + Term p = d_solver.mkConst(intPredSort, "p"); + Term zero = d_solver.mkInteger(0); + Term one = d_solver.mkInteger(1); + Term f_x = d_solver.mkTerm(APPLY_UF, f, x); + Term f_y = d_solver.mkTerm(APPLY_UF, f, y); + Term sum = d_solver.mkTerm(PLUS, f_x, f_y); + Term p_0 = d_solver.mkTerm(APPLY_UF, p, zero); + Term p_f_y = d_solver.mkTerm(APPLY_UF, p, f_y); + d_solver.assertFormula(d_solver.mkTerm(GT, zero, f_x)); + d_solver.assertFormula(d_solver.mkTerm(GT, zero, f_y)); + d_solver.assertFormula(d_solver.mkTerm(GT, sum, one)); + d_solver.assertFormula(p_0); + d_solver.assertFormula(p_f_y.notTerm()); + assertTrue(d_solver.checkSat().isUnsat()); + + AtomicReference<Term[]> atomic = new AtomicReference<>(); + assertDoesNotThrow(() -> atomic.set(d_solver.getUnsatCore())); + unsat_core = atomic.get(); + + d_solver.resetAssertions(); + for (Term t : unsat_core) + { + d_solver.assertFormula(t); + } + Result res = d_solver.checkSat(); + assertTrue(res.isUnsat()); + } + + @Test void getValue1() + { + d_solver.setOption("produce-models", "false"); + Term t = d_solver.mkTrue(); + d_solver.assertFormula(t); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getValue(t)); + } + + @Test void getValue2() + { + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkFalse(); + d_solver.assertFormula(t); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getValue(t)); + } + + @Test void getValue3() + { + d_solver.setOption("produce-models", "true"); + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort intSort = d_solver.getIntegerSort(); + Sort boolSort = d_solver.getBooleanSort(); + Sort uToIntSort = d_solver.mkFunctionSort(uSort, intSort); + Sort intPredSort = d_solver.mkFunctionSort(intSort, boolSort); + Term[] unsat_core; + + Term x = d_solver.mkConst(uSort, "x"); + Term y = d_solver.mkConst(uSort, "y"); + Term z = d_solver.mkConst(uSort, "z"); + Term f = d_solver.mkConst(uToIntSort, "f"); + Term p = d_solver.mkConst(intPredSort, "p"); + Term zero = d_solver.mkInteger(0); + Term one = d_solver.mkInteger(1); + Term f_x = d_solver.mkTerm(APPLY_UF, f, x); + Term f_y = d_solver.mkTerm(APPLY_UF, f, y); + Term sum = d_solver.mkTerm(PLUS, f_x, f_y); + Term p_0 = d_solver.mkTerm(APPLY_UF, p, zero); + Term p_f_y = d_solver.mkTerm(APPLY_UF, p, f_y); + + d_solver.assertFormula(d_solver.mkTerm(LEQ, zero, f_x)); + d_solver.assertFormula(d_solver.mkTerm(LEQ, zero, f_y)); + d_solver.assertFormula(d_solver.mkTerm(LEQ, sum, one)); + d_solver.assertFormula(p_0.notTerm()); + d_solver.assertFormula(p_f_y); + assertTrue(d_solver.checkSat().isSat()); + assertDoesNotThrow(() -> d_solver.getValue(x)); + assertDoesNotThrow(() -> d_solver.getValue(y)); + assertDoesNotThrow(() -> d_solver.getValue(z)); + assertDoesNotThrow(() -> d_solver.getValue(sum)); + assertDoesNotThrow(() -> d_solver.getValue(p_f_y)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.getValue(x)); + } + + @Test void getQuantifierElimination() + { + Term x = d_solver.mkVar(d_solver.getBooleanSort(), "x"); + Term forall = d_solver.mkTerm(FORALL, + d_solver.mkTerm(BOUND_VAR_LIST, x), + d_solver.mkTerm(OR, x, d_solver.mkTerm(NOT, x))); + assertThrows( + CVC5ApiException.class, () -> d_solver.getQuantifierElimination(d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, + () -> d_solver.getQuantifierElimination(new Solver().mkBoolean(false))); + + assertDoesNotThrow(() -> d_solver.getQuantifierElimination(forall)); + } + + @Test void getQuantifierEliminationDisjunct() + { + Term x = d_solver.mkVar(d_solver.getBooleanSort(), "x"); + Term forall = d_solver.mkTerm(FORALL, + d_solver.mkTerm(BOUND_VAR_LIST, x), + d_solver.mkTerm(OR, x, d_solver.mkTerm(NOT, x))); + assertThrows(CVC5ApiException.class, + () -> d_solver.getQuantifierEliminationDisjunct(d_solver.getNullTerm())); + + assertThrows(CVC5ApiException.class, + () -> d_solver.getQuantifierEliminationDisjunct(new Solver().mkBoolean(false))); + + assertDoesNotThrow(() -> d_solver.getQuantifierEliminationDisjunct(forall)); + } + + @Test void declareSeparationHeap() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + Sort integer = d_solver.getIntegerSort(); + assertDoesNotThrow(() -> d_solver.declareSeparationHeap(integer, integer)); + // cannot declare separation logic heap more than once + assertThrows(CVC5ApiException.class, () -> d_solver.declareSeparationHeap(integer, integer)); + } + + /** + * Helper function for testGetSeparation{Heap,Nil}TermX. Asserts and checks + * some simple separation logic constraints. + */ + + void checkSimpleSeparationConstraints(Solver solver) + { + Sort integer = solver.getIntegerSort(); + // declare the separation heap + solver.declareSeparationHeap(integer, integer); + Term x = solver.mkConst(integer, "x"); + Term p = solver.mkConst(integer, "p"); + Term heap = solver.mkTerm(SEP_PTO, p, x); + solver.assertFormula(heap); + Term nil = solver.mkSepNil(integer); + solver.assertFormula(nil.eqTerm(solver.mkReal(5))); + solver.checkSat(); + } + + @Test void getSeparationHeapTerm1() throws CVC5ApiException + { + d_solver.setLogic("QF_BV"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkTrue(); + d_solver.assertFormula(t); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationHeap()); + } + + @Test void getSeparationHeapTerm2() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "false"); + checkSimpleSeparationConstraints(d_solver); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationHeap()); + } + + @Test void getSeparationHeapTerm3() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkFalse(); + d_solver.assertFormula(t); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationHeap()); + } + + @Test void getSeparationHeapTerm4() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkTrue(); + d_solver.assertFormula(t); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationHeap()); + } + + @Test void getSeparationHeapTerm5() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + checkSimpleSeparationConstraints(d_solver); + assertDoesNotThrow(() -> d_solver.getSeparationHeap()); + } + + @Test void getSeparationNilTerm1() throws CVC5ApiException + { + d_solver.setLogic("QF_BV"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkTrue(); + d_solver.assertFormula(t); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationNilTerm()); + } + + @Test void getSeparationNilTerm2() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "false"); + checkSimpleSeparationConstraints(d_solver); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationNilTerm()); + } + + @Test void getSeparationNilTerm3() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkFalse(); + d_solver.assertFormula(t); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationNilTerm()); + } + + @Test void getSeparationNilTerm4() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + Term t = d_solver.mkTrue(); + d_solver.assertFormula(t); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.getSeparationNilTerm()); + } + + @Test void getSeparationNilTerm5() throws CVC5ApiException + { + d_solver.setLogic("ALL"); + d_solver.setOption("incremental", "false"); + d_solver.setOption("produce-models", "true"); + checkSimpleSeparationConstraints(d_solver); + assertDoesNotThrow(() -> d_solver.getSeparationNilTerm()); + } + + @Test void push1() + { + d_solver.setOption("incremental", "true"); + assertDoesNotThrow(() -> d_solver.push(1)); + assertThrows(CVC5ApiException.class, () -> d_solver.setOption("incremental", "false")); + assertThrows(CVC5ApiException.class, () -> d_solver.setOption("incremental", "true")); + } + + @Test void push2() + { + d_solver.setOption("incremental", "false"); + assertThrows(CVC5ApiException.class, () -> d_solver.push(1)); + } + + @Test void pop1() + { + d_solver.setOption("incremental", "false"); + assertThrows(CVC5ApiException.class, () -> d_solver.pop(1)); + } + + @Test void pop2() + { + d_solver.setOption("incremental", "true"); + assertThrows(CVC5ApiException.class, () -> d_solver.pop(1)); + } + + @Test void pop3() + { + d_solver.setOption("incremental", "true"); + assertDoesNotThrow(() -> d_solver.push(1)); + assertDoesNotThrow(() -> d_solver.pop(1)); + assertThrows(CVC5ApiException.class, () -> d_solver.pop(1)); + } + + @Test void blockModel1() + { + d_solver.setOption("produce-models", "true"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModel()); + } + + @Test void blockModel2() throws CVC5ApiException + { + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModel()); + } + + @Test void blockModel3() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModel()); + } + + @Test void blockModel4() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertDoesNotThrow(() -> d_solver.blockModel()); + } + + @Test void blockModelValues1() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModelValues(new Term[] {})); + assertThrows(CVC5ApiException.class, + () -> d_solver.blockModelValues(new Term[] {d_solver.getNullTerm()})); + assertThrows(CVC5ApiException.class, + () -> d_solver.blockModelValues(new Term[] {new Solver().mkBoolean(false)})); + } + + @Test void blockModelValues2() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModelValues(new Term[] {x})); + } + + @Test void blockModelValues3() throws CVC5ApiException + { + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModelValues(new Term[] {x})); + } + + @Test void blockModelValues4() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + assertThrows(CVC5ApiException.class, () -> d_solver.blockModelValues(new Term[] {x})); + } + + @Test void blockModelValues5() throws CVC5ApiException + { + d_solver.setOption("produce-models", "true"); + d_solver.setOption("block-models", "literals"); + Term x = d_solver.mkConst(d_solver.getBooleanSort(), "x"); + d_solver.assertFormula(x.eqTerm(x)); + d_solver.checkSat(); + assertDoesNotThrow(() -> d_solver.blockModelValues(new Term[] {x})); + } + + @Test void setInfo() throws CVC5ApiException + { + assertThrows(CVC5ApiException.class, () -> d_solver.setInfo("cvc4-lagic", "QF_BV")); + assertThrows(CVC5ApiException.class, () -> d_solver.setInfo("cvc2-logic", "QF_BV")); + assertThrows(CVC5ApiException.class, () -> d_solver.setInfo("cvc4-logic", "asdf")); + + assertDoesNotThrow(() -> d_solver.setInfo("source", "asdf")); + assertDoesNotThrow(() -> d_solver.setInfo("category", "asdf")); + assertDoesNotThrow(() -> d_solver.setInfo("difficulty", "asdf")); + assertDoesNotThrow(() -> d_solver.setInfo("filename", "asdf")); + assertDoesNotThrow(() -> d_solver.setInfo("license", "asdf")); + assertDoesNotThrow(() -> d_solver.setInfo("name", "asdf")); + assertDoesNotThrow(() -> d_solver.setInfo("notes", "asdf")); + + assertDoesNotThrow(() -> d_solver.setInfo("smt-lib-version", "2")); + assertDoesNotThrow(() -> d_solver.setInfo("smt-lib-version", "2.0")); + assertDoesNotThrow(() -> d_solver.setInfo("smt-lib-version", "2.5")); + assertDoesNotThrow(() -> d_solver.setInfo("smt-lib-version", "2.6")); + assertThrows(CVC5ApiException.class, () -> d_solver.setInfo("smt-lib-version", ".0")); + + assertDoesNotThrow(() -> d_solver.setInfo("status", "sat")); + assertDoesNotThrow(() -> d_solver.setInfo("status", "unsat")); + assertDoesNotThrow(() -> d_solver.setInfo("status", "unknown")); + assertThrows(CVC5ApiException.class, () -> d_solver.setInfo("status", "asdf")); + } + + @Test void simplify() throws CVC5ApiException + { + assertThrows(CVC5ApiException.class, () -> d_solver.simplify(d_solver.getNullTerm())); + + Sort bvSort = d_solver.mkBitVectorSort(32); + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort funSort1 = d_solver.mkFunctionSort(new Sort[] {bvSort, bvSort}, bvSort); + Sort funSort2 = d_solver.mkFunctionSort(uSort, d_solver.getIntegerSort()); + DatatypeDecl consListSpec = d_solver.mkDatatypeDecl("list"); + DatatypeConstructorDecl cons = d_solver.mkDatatypeConstructorDecl("cons"); + cons.addSelector("head", d_solver.getIntegerSort()); + cons.addSelectorSelf("tail"); + consListSpec.addConstructor(cons); + DatatypeConstructorDecl nil = d_solver.mkDatatypeConstructorDecl("nil"); + consListSpec.addConstructor(nil); + Sort consListSort = d_solver.mkDatatypeSort(consListSpec); + + Term x = d_solver.mkConst(bvSort, "x"); + assertDoesNotThrow(() -> d_solver.simplify(x)); + Term a = d_solver.mkConst(bvSort, "a"); + assertDoesNotThrow(() -> d_solver.simplify(a)); + Term b = d_solver.mkConst(bvSort, "b"); + assertDoesNotThrow(() -> d_solver.simplify(b)); + Term x_eq_x = d_solver.mkTerm(EQUAL, x, x); + assertDoesNotThrow(() -> d_solver.simplify(x_eq_x)); + assertNotEquals(d_solver.mkTrue(), x_eq_x); + assertEquals(d_solver.mkTrue(), d_solver.simplify(x_eq_x)); + Term x_eq_b = d_solver.mkTerm(EQUAL, x, b); + assertDoesNotThrow(() -> d_solver.simplify(x_eq_b)); + assertNotEquals(d_solver.mkTrue(), x_eq_b); + assertNotEquals(d_solver.mkTrue(), d_solver.simplify(x_eq_b)); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.simplify(x)); + + Term i1 = d_solver.mkConst(d_solver.getIntegerSort(), "i1"); + assertDoesNotThrow(() -> d_solver.simplify(i1)); + Term i2 = d_solver.mkTerm(MULT, i1, d_solver.mkInteger("23")); + assertDoesNotThrow(() -> d_solver.simplify(i2)); + assertNotEquals(i1, i2); + assertNotEquals(i1, d_solver.simplify(i2)); + Term i3 = d_solver.mkTerm(PLUS, i1, d_solver.mkInteger(0)); + assertDoesNotThrow(() -> d_solver.simplify(i3)); + assertNotEquals(i1, i3); + assertEquals(i1, d_solver.simplify(i3)); + + Datatype consList = consListSort.getDatatype(); + Term dt1 = d_solver.mkTerm(APPLY_CONSTRUCTOR, + consList.getConstructorTerm("cons"), + d_solver.mkInteger(0), + d_solver.mkTerm(APPLY_CONSTRUCTOR, consList.getConstructorTerm("nil"))); + assertDoesNotThrow(() -> d_solver.simplify(dt1)); + Term dt2 = d_solver.mkTerm( + APPLY_SELECTOR, consList.getConstructor("cons").getSelectorTerm("head"), dt1); + assertDoesNotThrow(() -> d_solver.simplify(dt2)); + + Term b1 = d_solver.mkVar(bvSort, "b1"); + assertDoesNotThrow(() -> d_solver.simplify(b1)); + Term b2 = d_solver.mkVar(bvSort, "b1"); + assertDoesNotThrow(() -> d_solver.simplify(b2)); + Term b3 = d_solver.mkVar(uSort, "b3"); + assertDoesNotThrow(() -> d_solver.simplify(b3)); + Term v1 = d_solver.mkConst(bvSort, "v1"); + assertDoesNotThrow(() -> d_solver.simplify(v1)); + Term v2 = d_solver.mkConst(d_solver.getIntegerSort(), "v2"); + assertDoesNotThrow(() -> d_solver.simplify(v2)); + Term f1 = d_solver.mkConst(funSort1, "f1"); + assertDoesNotThrow(() -> d_solver.simplify(f1)); + Term f2 = d_solver.mkConst(funSort2, "f2"); + assertDoesNotThrow(() -> d_solver.simplify(f2)); + d_solver.defineFunsRec(new Term[] {f1, f2}, new Term[][] {{b1, b2}, {b3}}, new Term[] {v1, v2}); + assertDoesNotThrow(() -> d_solver.simplify(f1)); + assertDoesNotThrow(() -> d_solver.simplify(f2)); + } + + @Test void assertFormula() + { + assertDoesNotThrow(() -> d_solver.assertFormula(d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> d_solver.assertFormula(d_solver.getNullTerm())); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.assertFormula(d_solver.mkTrue())); + } + + @Test void checkEntailed() + { + d_solver.setOption("incremental", "false"); + assertDoesNotThrow(() -> d_solver.checkEntailed(d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> d_solver.checkEntailed(d_solver.mkTrue())); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.checkEntailed(d_solver.mkTrue())); + } + + @Test void checkEntailed1() + { + Sort boolSort = d_solver.getBooleanSort(); + Term x = d_solver.mkConst(boolSort, "x"); + Term y = d_solver.mkConst(boolSort, "y"); + Term z = d_solver.mkTerm(AND, x, y); + d_solver.setOption("incremental", "true"); + assertDoesNotThrow(() -> d_solver.checkEntailed(d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> d_solver.checkEntailed(d_solver.getNullTerm())); + assertDoesNotThrow(() -> d_solver.checkEntailed(d_solver.mkTrue())); + assertDoesNotThrow(() -> d_solver.checkEntailed(z)); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.checkEntailed(d_solver.mkTrue())); + } + + @Test void checkEntailed2() + { + d_solver.setOption("incremental", "true"); + + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort intSort = d_solver.getIntegerSort(); + Sort boolSort = d_solver.getBooleanSort(); + Sort uToIntSort = d_solver.mkFunctionSort(uSort, intSort); + Sort intPredSort = d_solver.mkFunctionSort(intSort, boolSort); + + Term n = d_solver.getNullTerm(); + // Constants + Term x = d_solver.mkConst(uSort, "x"); + Term y = d_solver.mkConst(uSort, "y"); + // Functions + Term f = d_solver.mkConst(uToIntSort, "f"); + Term p = d_solver.mkConst(intPredSort, "p"); + // Values + Term zero = d_solver.mkInteger(0); + Term one = d_solver.mkInteger(1); + // Terms + Term f_x = d_solver.mkTerm(APPLY_UF, f, x); + Term f_y = d_solver.mkTerm(APPLY_UF, f, y); + Term sum = d_solver.mkTerm(PLUS, f_x, f_y); + Term p_0 = d_solver.mkTerm(APPLY_UF, p, zero); + Term p_f_y = d_solver.mkTerm(APPLY_UF, p, f_y); + // Assertions + Term assertions = d_solver.mkTerm(AND, + new Term[] { + d_solver.mkTerm(LEQ, zero, f_x), // 0 <= f(x) + d_solver.mkTerm(LEQ, zero, f_y), // 0 <= f(y) + d_solver.mkTerm(LEQ, sum, one), // f(x) + f(y) <= 1 + p_0.notTerm(), // not p(0) + p_f_y // p(f(y)) + }); + + assertDoesNotThrow(() -> d_solver.checkEntailed(d_solver.mkTrue())); + d_solver.assertFormula(assertions); + assertDoesNotThrow(() -> d_solver.checkEntailed(d_solver.mkTerm(DISTINCT, x, y))); + assertDoesNotThrow(() + -> d_solver.checkEntailed( + new Term[] {d_solver.mkFalse(), d_solver.mkTerm(DISTINCT, x, y)})); + assertThrows(CVC5ApiException.class, () -> d_solver.checkEntailed(n)); + assertThrows(CVC5ApiException.class, + () -> d_solver.checkEntailed(new Term[] {n, d_solver.mkTerm(DISTINCT, x, y)})); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.checkEntailed(d_solver.mkTrue())); + } + + @Test void checkSat() throws CVC5ApiException + { + d_solver.setOption("incremental", "false"); + assertDoesNotThrow(() -> d_solver.checkSat()); + assertThrows(CVC5ApiException.class, () -> d_solver.checkSat()); + } + + @Test void checkSatAssuming() throws CVC5ApiException + { + d_solver.setOption("incremental", "false"); + assertDoesNotThrow(() -> d_solver.checkSatAssuming(d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> d_solver.checkSatAssuming(d_solver.mkTrue())); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.checkSatAssuming(d_solver.mkTrue())); + } + + @Test void checkSatAssuming1() throws CVC5ApiException + { + Sort boolSort = d_solver.getBooleanSort(); + Term x = d_solver.mkConst(boolSort, "x"); + Term y = d_solver.mkConst(boolSort, "y"); + Term z = d_solver.mkTerm(AND, x, y); + d_solver.setOption("incremental", "true"); + assertDoesNotThrow(() -> d_solver.checkSatAssuming(d_solver.mkTrue())); + assertThrows(CVC5ApiException.class, () -> d_solver.checkSatAssuming(d_solver.getNullTerm())); + assertDoesNotThrow(() -> d_solver.checkSatAssuming(d_solver.mkTrue())); + assertDoesNotThrow(() -> d_solver.checkSatAssuming(z)); + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.checkSatAssuming(d_solver.mkTrue())); + } + + @Test void checkSatAssuming2() throws CVC5ApiException + { + d_solver.setOption("incremental", "true"); + + Sort uSort = d_solver.mkUninterpretedSort("u"); + Sort intSort = d_solver.getIntegerSort(); + Sort boolSort = d_solver.getBooleanSort(); + Sort uToIntSort = d_solver.mkFunctionSort(uSort, intSort); + Sort intPredSort = d_solver.mkFunctionSort(intSort, boolSort); + + Term n = d_solver.getNullTerm(); + // Constants + Term x = d_solver.mkConst(uSort, "x"); + Term y = d_solver.mkConst(uSort, "y"); + // Functions + Term f = d_solver.mkConst(uToIntSort, "f"); + Term p = d_solver.mkConst(intPredSort, "p"); + // Values + Term zero = d_solver.mkInteger(0); + Term one = d_solver.mkInteger(1); + // Terms + Term f_x = d_solver.mkTerm(APPLY_UF, f, x); + Term f_y = d_solver.mkTerm(APPLY_UF, f, y); + Term sum = d_solver.mkTerm(PLUS, f_x, f_y); + Term p_0 = d_solver.mkTerm(APPLY_UF, p, zero); + Term p_f_y = d_solver.mkTerm(APPLY_UF, p, f_y); + // Assertions + Term assertions = d_solver.mkTerm(AND, + new Term[] { + d_solver.mkTerm(LEQ, zero, f_x), // 0 <= f(x) + d_solver.mkTerm(LEQ, zero, f_y), // 0 <= f(y) + d_solver.mkTerm(LEQ, sum, one), // f(x) + f(y) <= 1 + p_0.notTerm(), // not p(0) + p_f_y // p(f(y)) + }); + + assertDoesNotThrow(() -> d_solver.checkSatAssuming(d_solver.mkTrue())); + d_solver.assertFormula(assertions); + assertDoesNotThrow(() -> d_solver.checkSatAssuming(d_solver.mkTerm(DISTINCT, x, y))); + assertDoesNotThrow(() + -> d_solver.checkSatAssuming( + new Term[] {d_solver.mkFalse(), d_solver.mkTerm(DISTINCT, x, y)})); + assertThrows(CVC5ApiException.class, () -> d_solver.checkSatAssuming(n)); + assertThrows(CVC5ApiException.class, + () -> d_solver.checkSatAssuming(new Term[] {n, d_solver.mkTerm(DISTINCT, x, y)})); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.checkSatAssuming(d_solver.mkTrue())); + } + + @Test void setLogic() throws CVC5ApiException { assertDoesNotThrow(() -> d_solver.setLogic("AUFLIRA")); - assertThrows(CVC5ApiException.class, () -> d_solver.setLogic("AF_BV")); + assertThrows(CVC5ApiException.class, () -> d_solver.setLogic("AF_BV")); + d_solver.assertFormula(d_solver.mkTrue()); + assertThrows(CVC5ApiException.class, () -> d_solver.setLogic("AUFLIRA")); + } + + @Test void setOption() throws CVC5ApiException + { + assertDoesNotThrow(() -> d_solver.setOption("bv-sat-solver", "minisat")); + assertThrows(CVC5ApiException.class, () -> d_solver.setOption("bv-sat-solver", "1")); + d_solver.assertFormula(d_solver.mkTrue()); + assertThrows(CVC5ApiException.class, () -> d_solver.setOption("bv-sat-solver", "minisat")); + } + + @Test void resetAssertions() throws CVC5ApiException + { + d_solver.setOption("incremental", "true"); + + Sort bvSort = d_solver.mkBitVectorSort(4); + Term one = d_solver.mkBitVector(4, 1); + Term x = d_solver.mkConst(bvSort, "x"); + Term ule = d_solver.mkTerm(BITVECTOR_ULE, x, one); + Term srem = d_solver.mkTerm(BITVECTOR_SREM, one, x); + d_solver.push(4); + Term slt = d_solver.mkTerm(BITVECTOR_SLT, srem, one); + d_solver.resetAssertions(); + d_solver.checkSatAssuming(new Term[] {slt, ule}); + } + + @Test void mkSygusVar() throws CVC5ApiException + { + Sort boolSort = d_solver.getBooleanSort(); + Sort intSort = d_solver.getIntegerSort(); + Sort funSort = d_solver.mkFunctionSort(intSort, boolSort); + + assertDoesNotThrow(() -> d_solver.mkSygusVar(boolSort)); + assertDoesNotThrow(() -> d_solver.mkSygusVar(funSort)); + assertDoesNotThrow(() -> d_solver.mkSygusVar(boolSort, ("b"))); + assertDoesNotThrow(() -> d_solver.mkSygusVar(funSort, "")); + + assertThrows(CVC5ApiException.class, () -> d_solver.mkSygusVar(d_solver.getNullSort())); + assertThrows(CVC5ApiException.class, () -> d_solver.mkSygusVar(d_solver.getNullSort(), "a")); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.mkSygusVar(boolSort)); + } + + @Test void mkSygusGrammar() throws CVC5ApiException + { + Term nullTerm = d_solver.getNullTerm(); + Term boolTerm = d_solver.mkBoolean(true); + Term boolVar = d_solver.mkVar(d_solver.getBooleanSort()); + Term intVar = d_solver.mkVar(d_solver.getIntegerSort()); + + assertDoesNotThrow(() -> d_solver.mkSygusGrammar(new Term[] {}, new Term[] {intVar})); + assertDoesNotThrow(() -> d_solver.mkSygusGrammar(new Term[] {boolVar}, new Term[] {intVar})); + + assertThrows( + CVC5ApiException.class, () -> d_solver.mkSygusGrammar(new Term[] {}, new Term[] {})); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkSygusGrammar(new Term[] {}, new Term[] {nullTerm})); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkSygusGrammar(new Term[] {}, new Term[] {boolTerm})); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkSygusGrammar(new Term[] {boolTerm}, new Term[] {intVar})); + + Solver slv = new Solver(); + Term boolVar2 = slv.mkVar(slv.getBooleanSort()); + Term intVar2 = slv.mkVar(slv.getIntegerSort()); + assertDoesNotThrow(() -> slv.mkSygusGrammar(new Term[] {boolVar2}, new Term[] {intVar2})); + + assertThrows(CVC5ApiException.class, + () -> slv.mkSygusGrammar(new Term[] {boolVar}, new Term[] {intVar2})); + assertThrows(CVC5ApiException.class, + () -> slv.mkSygusGrammar(new Term[] {boolVar2}, new Term[] {intVar})); + } + + @Test void synthFun() throws CVC5ApiException + { + Sort nullSort = d_solver.getNullSort(); + Sort bool = d_solver.getBooleanSort(); + Sort integer = d_solver.getIntegerSort(); + + Term nullTerm = d_solver.getNullTerm(); + Term x = d_solver.mkVar(bool); + + Term start1 = d_solver.mkVar(bool); + Term start2 = d_solver.mkVar(integer); + + Grammar g1 = d_solver.mkSygusGrammar(new Term[] {x}, new Term[] {start1}); + g1.addRule(start1, d_solver.mkBoolean(false)); + + Grammar g2 = d_solver.mkSygusGrammar(new Term[] {x}, new Term[] {start2}); + g2.addRule(start2, d_solver.mkInteger(0)); + + assertDoesNotThrow(() -> d_solver.synthFun("", new Term[] {}, bool)); + assertDoesNotThrow(() -> d_solver.synthFun("f1", new Term[] {x}, bool)); + assertDoesNotThrow(() -> d_solver.synthFun("f2", new Term[] {x}, bool, g1)); + + assertThrows( + CVC5ApiException.class, () -> d_solver.synthFun("f3", new Term[] {nullTerm}, bool)); + assertThrows(CVC5ApiException.class, () -> d_solver.synthFun("f4", new Term[] {}, nullSort)); + assertThrows(CVC5ApiException.class, () -> d_solver.synthFun("f6", new Term[] {x}, bool, g2)); + + Solver slv = new Solver(); + Term x2 = slv.mkVar(slv.getBooleanSort()); + assertDoesNotThrow(() -> slv.synthFun("f1", new Term[] {x2}, slv.getBooleanSort())); + + assertThrows( + CVC5ApiException.class, () -> slv.synthFun("", new Term[] {}, d_solver.getBooleanSort())); + assertThrows(CVC5ApiException.class, + () -> slv.synthFun("f1", new Term[] {x}, d_solver.getBooleanSort())); + } + + @Test void synthInv() throws CVC5ApiException + { + Sort bool = d_solver.getBooleanSort(); + Sort integer = d_solver.getIntegerSort(); + + Term nullTerm = d_solver.getNullTerm(); + Term x = d_solver.mkVar(bool); + + Term start1 = d_solver.mkVar(bool); + Term start2 = d_solver.mkVar(integer); + + Grammar g1 = d_solver.mkSygusGrammar(new Term[] {x}, new Term[] {start1}); + g1.addRule(start1, d_solver.mkBoolean(false)); + + Grammar g2 = d_solver.mkSygusGrammar(new Term[] {x}, new Term[] {start2}); + g2.addRule(start2, d_solver.mkInteger(0)); + + assertDoesNotThrow(() -> d_solver.synthInv("", new Term[] {})); + assertDoesNotThrow(() -> d_solver.synthInv("i1", new Term[] {x})); + assertDoesNotThrow(() -> d_solver.synthInv("i2", new Term[] {x}, g1)); + + assertThrows(CVC5ApiException.class, () -> d_solver.synthInv("i3", new Term[] {nullTerm})); + assertThrows(CVC5ApiException.class, () -> d_solver.synthInv("i4", new Term[] {x}, g2)); + } + + @Test void addSygusConstraint() throws CVC5ApiException + { + Term nullTerm = d_solver.getNullTerm(); + Term boolTerm = d_solver.mkBoolean(true); + Term intTerm = d_solver.mkInteger(1); + + assertDoesNotThrow(() -> d_solver.addSygusConstraint(boolTerm)); + assertThrows(CVC5ApiException.class, () -> d_solver.addSygusConstraint(nullTerm)); + assertThrows(CVC5ApiException.class, () -> d_solver.addSygusConstraint(intTerm)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.addSygusConstraint(boolTerm)); + } + + @Test void addSygusInvConstraint() throws CVC5ApiException + { + Sort bool = d_solver.getBooleanSort(); + Sort real = d_solver.getRealSort(); + + Term nullTerm = d_solver.getNullTerm(); + Term intTerm = d_solver.mkInteger(1); + + Term inv = d_solver.declareFun("inv", new Sort[] {real}, bool); + Term pre = d_solver.declareFun("pre", new Sort[] {real}, bool); + Term trans = d_solver.declareFun("trans", new Sort[] {real, real}, bool); + Term post = d_solver.declareFun("post", new Sort[] {real}, bool); + + Term inv1 = d_solver.declareFun("inv1", new Sort[] {real}, real); + + Term trans1 = d_solver.declareFun("trans1", new Sort[] {bool, real}, bool); + Term trans2 = d_solver.declareFun("trans2", new Sort[] {real, bool}, bool); + Term trans3 = d_solver.declareFun("trans3", new Sort[] {real, real}, real); + + assertDoesNotThrow(() -> d_solver.addSygusInvConstraint(inv, pre, trans, post)); + + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(nullTerm, pre, trans, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, nullTerm, trans, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, nullTerm, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, trans, nullTerm)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(intTerm, pre, trans, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv1, pre, trans, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, trans, trans, post)); + assertThrows(CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, pre, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, trans1, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, trans2, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, trans3, post)); + assertThrows( + CVC5ApiException.class, () -> d_solver.addSygusInvConstraint(inv, pre, trans, trans)); + + Solver slv = new Solver(); + Sort boolean2 = slv.getBooleanSort(); + Sort real2 = slv.getRealSort(); + Term inv22 = slv.declareFun("inv", new Sort[] {real2}, boolean2); + Term pre22 = slv.declareFun("pre", new Sort[] {real2}, boolean2); + Term trans22 = slv.declareFun("trans", new Sort[] {real2, real2}, boolean2); + Term post22 = slv.declareFun("post", new Sort[] {real2}, boolean2); + assertDoesNotThrow(() -> slv.addSygusInvConstraint(inv22, pre22, trans22, post22)); + + assertThrows( + CVC5ApiException.class, () -> slv.addSygusInvConstraint(inv, pre22, trans22, post22)); + assertThrows( + CVC5ApiException.class, () -> slv.addSygusInvConstraint(inv22, pre, trans22, post22)); + assertThrows( + CVC5ApiException.class, () -> slv.addSygusInvConstraint(inv22, pre22, trans, post22)); + assertThrows( + CVC5ApiException.class, () -> slv.addSygusInvConstraint(inv22, pre22, trans22, post)); + } + + @Test void getSynthSolution() throws CVC5ApiException + { + d_solver.setOption("lang", "sygus2"); + d_solver.setOption("incremental", "false"); + + Term nullTerm = d_solver.getNullTerm(); + Term x = d_solver.mkBoolean(false); + Term f = d_solver.synthFun("f", new Term[] {}, d_solver.getBooleanSort()); + + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolution(f)); + + d_solver.checkSynth(); + + assertDoesNotThrow(() -> d_solver.getSynthSolution(f)); + assertDoesNotThrow(() -> d_solver.getSynthSolution(f)); + + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolution(nullTerm)); + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolution(x)); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.getSynthSolution(f)); + } + + @Test void getSynthSolutions() throws CVC5ApiException + { + d_solver.setOption("lang", "sygus2"); + d_solver.setOption("incremental", "false"); + + Term nullTerm = d_solver.getNullTerm(); + Term x = d_solver.mkBoolean(false); + Term f = d_solver.synthFun("f", new Term[] {}, d_solver.getBooleanSort()); + + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolutions(new Term[] {})); + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolutions(new Term[] {f})); + + d_solver.checkSynth(); + + assertDoesNotThrow(() -> d_solver.getSynthSolutions(new Term[] {f})); + assertDoesNotThrow(() -> d_solver.getSynthSolutions(new Term[] {f, f})); + + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolutions(new Term[] {})); + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolutions(new Term[] {nullTerm})); + assertThrows(CVC5ApiException.class, () -> d_solver.getSynthSolutions(new Term[] {x})); + + Solver slv = new Solver(); + assertThrows(CVC5ApiException.class, () -> slv.getSynthSolutions(new Term[] {x})); + } + + @Test void tupleProject() throws CVC5ApiException + { + Sort[] sorts = new Sort[] {d_solver.getBooleanSort(), + d_solver.getIntegerSort(), + d_solver.getStringSort(), + d_solver.mkSetSort(d_solver.getStringSort())}; + Term[] elements = new Term[] {d_solver.mkBoolean(true), + d_solver.mkInteger(3), + d_solver.mkString("C"), + d_solver.mkTerm(SINGLETON, d_solver.mkString("Z"))}; + + Term tuple = d_solver.mkTuple(sorts, elements); + + int[] indices1 = new int[] {}; + int[] indices2 = new int[] {0}; + int[] indices3 = new int[] {0, 1}; + int[] indices4 = new int[] {0, 0, 2, 2, 3, 3, 0}; + int[] indices5 = new int[] {4}; + int[] indices6 = new int[] {0, 4}; + + assertDoesNotThrow(() -> d_solver.mkTerm(d_solver.mkOp(TUPLE_PROJECT, indices1), tuple)); + assertDoesNotThrow(() -> d_solver.mkTerm(d_solver.mkOp(TUPLE_PROJECT, indices2), tuple)); + assertDoesNotThrow(() -> d_solver.mkTerm(d_solver.mkOp(TUPLE_PROJECT, indices3), tuple)); + assertDoesNotThrow(() -> d_solver.mkTerm(d_solver.mkOp(TUPLE_PROJECT, indices4), tuple)); + + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(d_solver.mkOp(TUPLE_PROJECT, indices5), tuple)); + assertThrows(CVC5ApiException.class, + () -> d_solver.mkTerm(d_solver.mkOp(TUPLE_PROJECT, indices6), tuple)); + + int[] indices = new int[] {0, 3, 2, 0, 1, 2}; + + Op op = d_solver.mkOp(TUPLE_PROJECT, indices); + Term projection = d_solver.mkTerm(op, tuple); + + Datatype datatype = tuple.getSort().getDatatype(); + DatatypeConstructor constructor = datatype.getConstructor(0); + + for (int i = 0; i < indices.length; i++) + { + Term selectorTerm = constructor.getSelector(indices[i]).getSelectorTerm(); + Term selectedTerm = d_solver.mkTerm(APPLY_SELECTOR, selectorTerm, tuple); + Term simplifiedTerm = d_solver.simplify(selectedTerm); + assertEquals(elements[indices[i]], simplifiedTerm); + } + + assertEquals("((_ tuple_project 0 3 2 0 1 2) (mkTuple true 3 \"C\" (singleton " + + "\"Z\")))", + projection.toString()); } -} +}
\ No newline at end of file diff --git a/test/unit/api/java/cvc5/SortTest.java b/test/unit/api/java/cvc5/SortTest.java index a937e4dfc..f2f9edaed 100644 --- a/test/unit/api/java/cvc5/SortTest.java +++ b/test/unit/api/java/cvc5/SortTest.java @@ -64,7 +64,7 @@ class SortTest { assertDoesNotThrow(() -> d_solver.getIntegerSort() == d_solver.getNullSort()); assertDoesNotThrow(() -> d_solver.getIntegerSort() != d_solver.getNullSort()); - assertDoesNotThrow(() -> d_solver.getIntegerSort().compareTo(d_solver.getNullSort())); + assertDoesNotThrow(() -> d_solver.getIntegerSort().compareTo(d_solver.getNullSort())); } @Test void isBoolean() @@ -101,11 +101,8 @@ class SortTest @Test void isRoundingMode() throws CVC5ApiException { - if (d_solver.supportsFloatingPoint()) - { - assertTrue(d_solver.getRoundingModeSort().isRoundingMode()); - assertDoesNotThrow(() -> d_solver.getNullSort().isRoundingMode()); - } + assertTrue(d_solver.getRoundingModeSort().isRoundingMode()); + assertDoesNotThrow(() -> d_solver.getNullSort().isRoundingMode()); } @Test void isBitVector() throws CVC5ApiException @@ -116,11 +113,8 @@ class SortTest @Test void isFloatingPoint() throws CVC5ApiException { - if (d_solver.supportsFloatingPoint()) - { - assertTrue(d_solver.mkFloatingPointSort(8, 24).isFloatingPoint()); - assertDoesNotThrow(() -> d_solver.getNullSort().isFloatingPoint()); - } + assertTrue(d_solver.mkFloatingPointSort(8, 24).isFloatingPoint()); + assertDoesNotThrow(() -> d_solver.getNullSort().isFloatingPoint()); } @Test void isDatatype() throws CVC5ApiException @@ -474,24 +468,18 @@ class SortTest @Test void getFPExponentSize() throws CVC5ApiException { - if (d_solver.supportsFloatingPoint()) - { - Sort fpSort = d_solver.mkFloatingPointSort(4, 8); - assertDoesNotThrow(() -> fpSort.getFPExponentSize()); - Sort setSort = d_solver.mkSetSort(d_solver.getIntegerSort()); - assertThrows(CVC5ApiException.class, () -> setSort.getFPExponentSize()); - } + Sort fpSort = d_solver.mkFloatingPointSort(4, 8); + assertDoesNotThrow(() -> fpSort.getFPExponentSize()); + Sort setSort = d_solver.mkSetSort(d_solver.getIntegerSort()); + assertThrows(CVC5ApiException.class, () -> setSort.getFPExponentSize()); } @Test void getFPSignificandSize() throws CVC5ApiException { - if (d_solver.supportsFloatingPoint()) - { - Sort fpSort = d_solver.mkFloatingPointSort(4, 8); - assertDoesNotThrow(() -> fpSort.getFPSignificandSize()); - Sort setSort = d_solver.mkSetSort(d_solver.getIntegerSort()); - assertThrows(CVC5ApiException.class, () -> setSort.getFPSignificandSize()); - } + Sort fpSort = d_solver.mkFloatingPointSort(4, 8); + assertDoesNotThrow(() -> fpSort.getFPSignificandSize()); + Sort setSort = d_solver.mkSetSort(d_solver.getIntegerSort()); + assertThrows(CVC5ApiException.class, () -> setSort.getFPSignificandSize()); } @Test void getDatatypeParamSorts() throws CVC5ApiException diff --git a/test/unit/api/java/cvc5/TermTest.java b/test/unit/api/java/cvc5/TermTest.java index d5491e0e7..508e264e3 100644 --- a/test/unit/api/java/cvc5/TermTest.java +++ b/test/unit/api/java/cvc5/TermTest.java @@ -27,16 +27,17 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -class TermTest { +class TermTest +{ private Solver d_solver; - @BeforeEach - void setUp() { + @BeforeEach void setUp() + { d_solver = new Solver(); } - @Test - void eq() { + @Test void eq() + { Sort uSort = d_solver.mkUninterpretedSort("u"); Term x = d_solver.mkVar(uSort, "x"); Term y = d_solver.mkVar(uSort, "y"); @@ -50,8 +51,8 @@ class TermTest { assertTrue(x != z); } - @Test - void getId() { + @Test void getId() + { Term n = d_solver.getNullTerm(); assertThrows(CVC5ApiException.class, () -> n.getId()); Term x = d_solver.mkVar(d_solver.getIntegerSort(), "x"); @@ -63,8 +64,8 @@ class TermTest { assertNotEquals(x.getId(), z.getId()); } - @Test - void getKind() throws CVC5ApiException { + @Test void getKind() throws CVC5ApiException + { Sort uSort = d_solver.mkUninterpretedSort("u"); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -105,8 +106,8 @@ class TermTest { assertEquals(ss.getKind(), SEQ_CONCAT); } - @Test - void getSort() throws CVC5ApiException { + @Test void getSort() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -150,8 +151,8 @@ class TermTest { assertEquals(p_f_y.getSort(), boolSort); } - @Test - void getOp() throws CVC5ApiException { + @Test void getOp() throws CVC5ApiException + { Sort intsort = d_solver.getIntegerSort(); Sort bvsort = d_solver.mkBitVectorSort(8); Sort arrsort = d_solver.mkArraySort(bvsort, intsort); @@ -184,7 +185,8 @@ class TermTest { List<Term> children = new ArrayList(); Iterator<Term> iterator = fx.iterator(); - for (Term t : fx) { + for (Term t : fx) + { children.add(t); } @@ -201,8 +203,7 @@ class TermTest { listDecl.addConstructor(cons); listDecl.addConstructor(nil); Sort listSort = d_solver.mkDatatypeSort(listDecl); - Sort intListSort = - listSort.instantiate(new Sort[] {d_solver.getIntegerSort()}); + Sort intListSort = listSort.instantiate(new Sort[] {d_solver.getIntegerSort()}); Term c = d_solver.mkConst(intListSort, "c"); Datatype list = listSort.getDatatype(); // list datatype constructor and selector operator terms @@ -210,24 +211,23 @@ class TermTest { Term nilOpTerm = list.getConstructorTerm("nil"); } - @Test - void isNull() throws CVC5ApiException { + @Test void isNull() throws CVC5ApiException + { Term x = d_solver.getNullTerm(); assertTrue(x.isNull()); x = d_solver.mkVar(d_solver.mkBitVectorSort(4), "x"); assertFalse(x.isNull()); } - @Test - void notTerm() throws CVC5ApiException { + @Test void notTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); Sort funSort1 = d_solver.mkFunctionSort(bvSort, intSort); Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().notTerm()); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().notTerm()); Term b = d_solver.mkTrue(); assertDoesNotThrow(() -> b.notTerm()); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); @@ -248,8 +248,8 @@ class TermTest { assertDoesNotThrow(() -> p_f_x.notTerm()); } - @Test - void andTerm() throws CVC5ApiException { + @Test void andTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -257,10 +257,8 @@ class TermTest { Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); Term b = d_solver.mkTrue(); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().andTerm(b)); - assertThrows( - CVC5ApiException.class, () -> b.andTerm(d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().andTerm(b)); + assertThrows(CVC5ApiException.class, () -> b.andTerm(d_solver.getNullTerm())); assertDoesNotThrow(() -> b.andTerm(b)); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); assertThrows(CVC5ApiException.class, () -> x.andTerm(b)); @@ -316,8 +314,8 @@ class TermTest { assertDoesNotThrow(() -> p_f_x.andTerm(p_f_x)); } - @Test - void orTerm() throws CVC5ApiException { + @Test void orTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -325,10 +323,8 @@ class TermTest { Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); Term b = d_solver.mkTrue(); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().orTerm(b)); - assertThrows( - CVC5ApiException.class, () -> b.orTerm(d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().orTerm(b)); + assertThrows(CVC5ApiException.class, () -> b.orTerm(d_solver.getNullTerm())); assertDoesNotThrow(() -> b.orTerm(b)); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); assertThrows(CVC5ApiException.class, () -> x.orTerm(b)); @@ -384,8 +380,8 @@ class TermTest { assertDoesNotThrow(() -> p_f_x.orTerm(p_f_x)); } - @Test - void xorTerm() throws CVC5ApiException { + @Test void xorTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -393,10 +389,8 @@ class TermTest { Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); Term b = d_solver.mkTrue(); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().xorTerm(b)); - assertThrows( - CVC5ApiException.class, () -> b.xorTerm(d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().xorTerm(b)); + assertThrows(CVC5ApiException.class, () -> b.xorTerm(d_solver.getNullTerm())); assertDoesNotThrow(() -> b.xorTerm(b)); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); assertThrows(CVC5ApiException.class, () -> x.xorTerm(b)); @@ -452,8 +446,8 @@ class TermTest { assertDoesNotThrow(() -> p_f_x.xorTerm(p_f_x)); } - @Test - void eqTerm() throws CVC5ApiException { + @Test void eqTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -461,10 +455,8 @@ class TermTest { Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); Term b = d_solver.mkTrue(); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().eqTerm(b)); - assertThrows( - CVC5ApiException.class, () -> b.eqTerm(d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().eqTerm(b)); + assertThrows(CVC5ApiException.class, () -> b.eqTerm(d_solver.getNullTerm())); assertDoesNotThrow(() -> b.eqTerm(b)); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); assertThrows(CVC5ApiException.class, () -> x.eqTerm(b)); @@ -520,8 +512,8 @@ class TermTest { assertDoesNotThrow(() -> p_f_x.eqTerm(p_f_x)); } - @Test - void impTerm() throws CVC5ApiException { + @Test void impTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -529,10 +521,8 @@ class TermTest { Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); Term b = d_solver.mkTrue(); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().impTerm(b)); - assertThrows( - CVC5ApiException.class, () -> b.impTerm(d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().impTerm(b)); + assertThrows(CVC5ApiException.class, () -> b.impTerm(d_solver.getNullTerm())); assertDoesNotThrow(() -> b.impTerm(b)); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); assertThrows(CVC5ApiException.class, () -> x.impTerm(b)); @@ -588,8 +578,8 @@ class TermTest { assertDoesNotThrow(() -> p_f_x.impTerm(p_f_x)); } - @Test - void iteTerm() throws CVC5ApiException { + @Test void iteTerm() throws CVC5ApiException + { Sort bvSort = d_solver.mkBitVectorSort(8); Sort intSort = d_solver.getIntegerSort(); Sort boolSort = d_solver.getBooleanSort(); @@ -597,12 +587,9 @@ class TermTest { Sort funSort2 = d_solver.mkFunctionSort(intSort, boolSort); Term b = d_solver.mkTrue(); - assertThrows( - CVC5ApiException.class, () -> d_solver.getNullTerm().iteTerm(b, b)); - assertThrows( - CVC5ApiException.class, () -> b.iteTerm(d_solver.getNullTerm(), b)); - assertThrows( - CVC5ApiException.class, () -> b.iteTerm(b, d_solver.getNullTerm())); + assertThrows(CVC5ApiException.class, () -> d_solver.getNullTerm().iteTerm(b, b)); + assertThrows(CVC5ApiException.class, () -> b.iteTerm(d_solver.getNullTerm(), b)); + assertThrows(CVC5ApiException.class, () -> b.iteTerm(b, d_solver.getNullTerm())); assertDoesNotThrow(() -> b.iteTerm(b, b)); Term x = d_solver.mkVar(d_solver.mkBitVectorSort(8), "x"); assertDoesNotThrow(() -> b.iteTerm(x, x)); @@ -635,30 +622,27 @@ class TermTest { assertThrows(CVC5ApiException.class, () -> p_f_x.iteTerm(x, b)); } - @Test - void termAssignment() { + @Test void termAssignment() + { Term t1 = d_solver.mkInteger(1); Term t2 = t1; t2 = d_solver.mkInteger(2); assertEquals(t1, d_solver.mkInteger(1)); } - @Test - void termCompare() { + @Test void termCompare() + { Term t1 = d_solver.mkInteger(1); - Term t2 = - d_solver.mkTerm(PLUS, d_solver.mkInteger(2), d_solver.mkInteger(2)); - Term t3 = - d_solver.mkTerm(PLUS, d_solver.mkInteger(2), d_solver.mkInteger(2)); + Term t2 = d_solver.mkTerm(PLUS, d_solver.mkInteger(2), d_solver.mkInteger(2)); + Term t3 = d_solver.mkTerm(PLUS, d_solver.mkInteger(2), d_solver.mkInteger(2)); assertTrue(t2.compareTo(t3) >= 0); assertTrue(t2.compareTo(t3) <= 0); assertTrue((t1.compareTo(t2) > 0) != (t1.compareTo(t2) < 0)); - assertTrue( - (t1.compareTo(t2) > 0 || t1.equals(t2)) == (t1.compareTo(t2) >= 0)); + assertTrue((t1.compareTo(t2) > 0 || t1.equals(t2)) == (t1.compareTo(t2) >= 0)); } - @Test - void termChildren() throws CVC5ApiException { + @Test void termChildren() throws CVC5ApiException + { // simple term 2+3 Term two = d_solver.mkInteger(2); Term t1 = d_solver.mkTerm(PLUS, two, d_solver.mkInteger(3)); @@ -679,8 +663,8 @@ class TermTest { assertThrows(CVC5ApiException.class, () -> tnull.getChild(0)); } - @Test - void getInteger() throws CVC5ApiException { + @Test void getInteger() throws CVC5ApiException + { Term int1 = d_solver.mkInteger("-18446744073709551616"); Term int2 = d_solver.mkInteger("-18446744073709551615"); Term int3 = d_solver.mkInteger("-4294967296"); @@ -727,7 +711,6 @@ class TermTest { assertEquals(int7.getLong(), 10); assertEquals(int7.getInteger(), "10"); assertTrue(!int8.isInt() && int8.isLong() && int8.isInteger()); - assertEquals(Integer.toUnsignedLong(int8.getInt()), 4294967295L); assertEquals(int8.getLong(), 4294967295L); assertEquals(int8.getInteger(), "4294967295"); assertTrue(!int9.isInt() && int9.isLong() && int9.isInteger()); @@ -735,23 +718,20 @@ class TermTest { assertEquals(int9.getInteger(), "4294967296"); assertTrue(!int10.isInt() && !int10.isLong() && int10.isInteger()); - assertEquals(Long.compareUnsigned(int10.getLong(), - new BigInteger("18446744073709551615").longValue()), - 0); assertEquals(int10.getInteger(), "18446744073709551615"); assertTrue(!int11.isInt() && !int11.isLong() && int11.isInteger()); assertEquals(int11.getInteger(), "18446744073709551616"); } - @Test - void getString() { + @Test void getString() + { Term s1 = d_solver.mkString("abcde"); assertTrue(s1.isString()); assertEquals(s1.getString(), "abcde"); } - @Test - void substitute() { + @Test void substitute() + { Term x = d_solver.mkConst(d_solver.getIntegerSort(), "x"); Term one = d_solver.mkInteger(1); Term ttrue = d_solver.mkTrue(); @@ -801,8 +781,8 @@ class TermTest { assertThrows(CVC5ApiException.class, () -> xpx.substitute(es, rs)); } - @Test - void constArray() throws CVC5ApiException { + @Test void constArray() throws CVC5ApiException + { Sort intsort = d_solver.getIntegerSort(); Sort arrsort = d_solver.mkArraySort(intsort, intsort); Term a = d_solver.mkConst(arrsort, "a"); @@ -813,19 +793,15 @@ class TermTest { assertEquals(constarr.getConstArrayBase(), one); assertThrows(CVC5ApiException.class, () -> a.getConstArrayBase()); - arrsort = - d_solver.mkArraySort(d_solver.getRealSort(), d_solver.getRealSort()); + arrsort = d_solver.mkArraySort(d_solver.getRealSort(), d_solver.getRealSort()); Term zero_array = d_solver.mkConstArray(arrsort, d_solver.mkReal(0)); - Term stores = d_solver.mkTerm( - STORE, zero_array, d_solver.mkReal(1), d_solver.mkReal(2)); - stores = - d_solver.mkTerm(STORE, stores, d_solver.mkReal(2), d_solver.mkReal(3)); - stores = - d_solver.mkTerm(STORE, stores, d_solver.mkReal(4), d_solver.mkReal(5)); + Term stores = d_solver.mkTerm(STORE, zero_array, d_solver.mkReal(1), d_solver.mkReal(2)); + stores = d_solver.mkTerm(STORE, stores, d_solver.mkReal(2), d_solver.mkReal(3)); + stores = d_solver.mkTerm(STORE, stores, d_solver.mkReal(4), d_solver.mkReal(5)); } - @Test - void constSequenceElements() throws CVC5ApiException { + @Test void constSequenceElements() throws CVC5ApiException + { Sort realsort = d_solver.getRealSort(); Sort seqsort = d_solver.mkSequenceSort(realsort); Term s = d_solver.mkEmptySequence(seqsort); @@ -841,8 +817,8 @@ class TermTest { assertThrows(CVC5ApiException.class, () -> su.getConstSequenceElements()); } - @Test - void termScopedToString() { + @Test void termScopedToString() + { Sort intsort = d_solver.getIntegerSort(); Term x = d_solver.mkConst(intsort, "x"); assertEquals(x.toString(), "x"); |