Branch data Line data Source code
1 : : /******************************************************************************
2 : : * This file is part of the cvc5 project.
3 : : *
4 : : * Copyright (c) 2009-2026 by the authors listed in the file AUTHORS
5 : : * in the top-level source directory and their institutional affiliations.
6 : : * All rights reserved. See the file COPYING in the top-level source
7 : : * directory for licensing information.
8 : : * ****************************************************************************
9 : : *
10 : : * Black box testing of solver functions of the C API.
11 : : */
12 : :
13 : : extern "C" {
14 : : #include <cvc5/c/cvc5.h>
15 : : }
16 : :
17 : : #include <cvc5/c/cvc5.h>
18 : :
19 : : #include <cmath>
20 : : #include <cstring>
21 : : #include <fstream>
22 : :
23 : : #include "base/check.h"
24 : : #include "base/output.h"
25 : : #include "gtest/gtest.h"
26 : : #include "test_capi.h"
27 : :
28 : : namespace cvc5::internal::test {
29 : :
30 : : class TestCApiBlackSolver : public ::testing::Test
31 : : {
32 : : protected:
33 : 137 : void SetUp() override
34 : : {
35 : 137 : d_tm = cvc5_term_manager_new();
36 : 137 : d_solver = cvc5_new(d_tm);
37 : 137 : d_bool = cvc5_get_boolean_sort(d_tm);
38 : 137 : d_int = cvc5_get_integer_sort(d_tm);
39 : 137 : d_real = cvc5_get_real_sort(d_tm);
40 : 137 : d_str = cvc5_get_string_sort(d_tm);
41 : 137 : d_uninterpreted = cvc5_mk_uninterpreted_sort(d_tm, "u");
42 : 137 : }
43 : 137 : void TearDown() override
44 : : {
45 : 137 : cvc5_delete(d_solver);
46 : 137 : cvc5_term_manager_release(d_tm);
47 : 137 : cvc5_term_manager_delete(d_tm);
48 : 137 : }
49 : :
50 : : /**
51 : : * Helper function for testGetSeparation{Heap,Nil}TermX. Asserts and checks
52 : : * some simple separation logic constraints.
53 : : */
54 : 4 : void check_simple_separation_constraints()
55 : : {
56 : : // declare the separation heap
57 : 4 : cvc5_declare_sep_heap(d_solver, d_int, d_int);
58 : 4 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
59 : 4 : Cvc5Term p = cvc5_mk_const(d_tm, d_int, "p");
60 : 4 : std::vector<Cvc5Term> args = {p, x};
61 : : Cvc5Term heap =
62 : 4 : cvc5_mk_term(d_tm, CVC5_KIND_SEP_PTO, args.size(), args.data());
63 : 4 : cvc5_assert_formula(d_solver, heap);
64 : 4 : Cvc5Term nil = cvc5_mk_sep_nil(d_tm, d_int);
65 : 4 : args = {nil, cvc5_mk_integer_int64(d_tm, 5)};
66 : 4 : cvc5_assert_formula(
67 : : d_solver,
68 : 4 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
69 : 4 : cvc5_check_sat(d_solver);
70 : 4 : }
71 : :
72 : : Cvc5TermManager* d_tm;
73 : : Cvc5* d_solver;
74 : : Cvc5Sort d_bool;
75 : : Cvc5Sort d_int;
76 : : Cvc5Sort d_real;
77 : : Cvc5Sort d_str;
78 : : Cvc5Sort d_uninterpreted;
79 : : };
80 : :
81 : 4 : TEST_F(TestCApiBlackSolver, new)
82 : : {
83 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_new(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
84 : : }
85 : :
86 : 4 : TEST_F(TestCApiBlackSolver, pow2_large1)
87 : : {
88 : : // Based on https://github.com/cvc5/cvc5-projects/issues/371
89 : 1 : Cvc5Sort s4 = cvc5_mk_array_sort(d_tm, d_str, d_int);
90 : 1 : Cvc5Sort s7 = cvc5_mk_array_sort(d_tm, d_int, d_str);
91 : 1 : Cvc5Term t10 = cvc5_mk_integer(d_tm, "68038927088685865242724985643");
92 : 1 : Cvc5Term t74 = cvc5_mk_integer(d_tm, "8416288636405");
93 : 1 : Cvc5DatatypeConstructorDecl cons1 = cvc5_mk_dt_cons_decl(d_tm, "_x109");
94 : 1 : cvc5_dt_cons_decl_add_selector(cons1, "_x108", s7);
95 : 1 : Cvc5DatatypeConstructorDecl cons2 = cvc5_mk_dt_cons_decl(d_tm, "_x113");
96 : 1 : cvc5_dt_cons_decl_add_selector(cons2, "_x110", s4);
97 : 1 : cvc5_dt_cons_decl_add_selector(cons2, "_x111", d_int);
98 : 1 : cvc5_dt_cons_decl_add_selector(cons2, "_x112", s7);
99 : 1 : std::vector<Cvc5DatatypeConstructorDecl> ctors = {cons1, cons2};
100 : 1 : Cvc5Sort s11 = cvc5_declare_dt(d_solver, "_x107", ctors.size(), ctors.data());
101 : 1 : Cvc5Term t82 = cvc5_mk_const(d_tm, s11, "_x114");
102 : 1 : std::vector<Cvc5Term> args = {t10};
103 : 1 : Cvc5Term t180 = cvc5_mk_term(d_tm, CVC5_KIND_POW2, args.size(), args.data());
104 : 1 : args = {t74, t180};
105 : 1 : Cvc5Term t258 = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
106 : 1 : cvc5_assert_formula(d_solver, t258);
107 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_simplify(d_solver, t82, true),
[ - + ][ + - ]
[ + - ][ + - ]
108 : : "can only be a positive integral constant below");
109 [ + - ][ + - ]: 1 : }
110 : :
111 : 4 : TEST_F(TestCApiBlackSolver, pow2_large2)
112 : : {
113 : : // Based on https://github.com/cvc5/cvc5-projects/issues/333
114 : 1 : Cvc5Term t1 = cvc5_mk_bv_uint64(d_tm, 63, ~(((uint64_t)1) << 62));
115 : 1 : std::vector<Cvc5Term> args = {t1};
116 : 1 : Cvc5Term t2 = cvc5_mk_term(
117 : 1 : d_tm, CVC5_KIND_BITVECTOR_UBV_TO_INT, args.size(), args.data());
118 : 1 : args = {t2};
119 : 1 : Cvc5Term t3 = cvc5_mk_term(d_tm, CVC5_KIND_POW2, args.size(), args.data());
120 : 1 : args = {t3, t2};
121 : : Cvc5Term t4 =
122 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_DISTINCT, args.size(), args.data());
123 : 1 : std::vector<Cvc5Term> assumptions = {t4};
124 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
125 : : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data()),
126 : : "can only be a positive integral constant below");
127 [ + - ][ + - ]: 1 : }
128 : :
129 : 4 : TEST_F(TestCApiBlackSolver, pow2_large3)
130 : : {
131 : : // Based on https://github.com/cvc5/cvc5-projects/issues/339
132 : 1 : Cvc5Term t203 = cvc5_mk_integer(d_tm, "6135470354240554220207");
133 : 1 : std::vector<Cvc5Term> args = {t203};
134 : 1 : Cvc5Term t262 = cvc5_mk_term(d_tm, CVC5_KIND_POW2, args.size(), args.data());
135 : 1 : args = {t262};
136 : 1 : std::vector<uint32_t> idxs = {49};
137 : 2 : Cvc5Term t536 = cvc5_mk_term_from_op(
138 : : d_tm,
139 : 1 : cvc5_mk_op(d_tm, CVC5_KIND_INT_TO_BITVECTOR, idxs.size(), idxs.data()),
140 : : args.size(),
141 : 1 : args.data());
142 : : // should not throw an exception, will not simplify.
143 : 1 : cvc5_simplify(d_solver, t536, false);
144 : 1 : }
145 : :
146 : 4 : TEST_F(TestCApiBlackSolver, simplify)
147 : : {
148 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
149 : 1 : std::vector<Cvc5Sort> domain = {bv_sort, bv_sort};
150 : : Cvc5Sort fun_sort1 =
151 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), bv_sort);
152 : 1 : domain = {d_uninterpreted};
153 : : Cvc5Sort fun_sort2 =
154 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
155 : :
156 : 1 : Cvc5DatatypeDecl decl = cvc5_mk_dt_decl(d_tm, "list", false);
157 : 1 : Cvc5DatatypeConstructorDecl cons = cvc5_mk_dt_cons_decl(d_tm, "cons");
158 : 1 : cvc5_dt_cons_decl_add_selector(cons, "head", d_int);
159 : 1 : cvc5_dt_cons_decl_add_selector_self(cons, "tail");
160 : 1 : cvc5_dt_decl_add_constructor(decl, cons);
161 : 1 : Cvc5DatatypeConstructorDecl nil = cvc5_mk_dt_cons_decl(d_tm, "nil");
162 : 1 : cvc5_dt_decl_add_constructor(decl, nil);
163 : 1 : Cvc5Sort list = cvc5_mk_dt_sort(d_tm, decl);
164 : :
165 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, bv_sort, "x");
166 : 1 : (void)cvc5_simplify(d_solver, x, false);
167 : :
168 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_simplify(nullptr, x, false),
[ - + ][ + - ]
[ + - ][ + - ]
169 : : "unexpected NULL argument");
170 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_simplify(d_solver, nullptr, false), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
171 : :
172 : 1 : Cvc5Term a = cvc5_mk_const(d_tm, bv_sort, "a");
173 : 1 : (void)cvc5_simplify(d_solver, a, false);
174 : 1 : Cvc5Term b = cvc5_mk_const(d_tm, bv_sort, "b");
175 : 1 : (void)cvc5_simplify(d_solver, b, false);
176 : 1 : std::vector<Cvc5Term> args = {x, x};
177 : : Cvc5Term x_eq_x =
178 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
179 : 1 : (void)cvc5_simplify(d_solver, x_eq_x, false);
180 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(cvc5_mk_true(d_tm), x_eq_x));
181 [ - + ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(cvc5_mk_true(d_tm),
182 [ + - ]: 1 : cvc5_simplify(d_solver, x_eq_x, false)));
183 : 1 : args = {x, b};
184 : : Cvc5Term x_eq_b =
185 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
186 : 1 : (void)cvc5_simplify(d_solver, x_eq_b, false);
187 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(cvc5_mk_true(d_tm), x_eq_b));
188 [ - + ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(cvc5_mk_true(d_tm),
189 [ + - ]: 1 : cvc5_simplify(d_solver, x_eq_b, false)));
190 : :
191 : 1 : Cvc5Term i1 = cvc5_mk_const(d_tm, d_int, "i1");
192 : 1 : (void)cvc5_simplify(d_solver, i1, false);
193 : 1 : args = {i1, cvc5_mk_integer(d_tm, "23")};
194 : 1 : Cvc5Term i2 = cvc5_mk_term(d_tm, CVC5_KIND_MULT, args.size(), args.data());
195 : 1 : (void)cvc5_simplify(d_solver, i2, false);
196 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(i1, i2));
197 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(i1, cvc5_simplify(d_solver, i2, false)));
198 : :
199 : 1 : args = {i1, cvc5_mk_integer(d_tm, "0")};
200 : 1 : Cvc5Term i3 = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
201 : 1 : (void)cvc5_simplify(d_solver, i3, false);
202 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(i1, i3));
203 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(i1, cvc5_simplify(d_solver, i3, false)));
204 : :
205 : 1 : Cvc5Datatype list_dt = cvc5_sort_get_datatype(list);
206 : 0 : args = {
207 : 1 : cvc5_dt_cons_get_term(cvc5_dt_get_constructor_by_name(list_dt, "nil"))};
208 : 0 : args = {
209 : 1 : cvc5_dt_cons_get_term(cvc5_dt_get_constructor_by_name(list_dt, "cons")),
210 : 1 : cvc5_mk_integer(d_tm, "0"),
211 : 1 : cvc5_mk_term(
212 : 2 : d_tm, CVC5_KIND_APPLY_CONSTRUCTOR, args.size(), args.data())};
213 : : Cvc5Term dt1 =
214 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_CONSTRUCTOR, args.size(), args.data());
215 : 1 : (void)cvc5_simplify(d_solver, dt1, false);
216 : :
217 : 1 : args = {cvc5_dt_sel_get_term(cvc5_dt_cons_get_selector_by_name(
218 : : cvc5_dt_get_constructor_by_name(list_dt, "cons"), "head")),
219 : 1 : dt1};
220 : : Cvc5Term dt2 =
221 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_SELECTOR, args.size(), args.data());
222 : 1 : (void)cvc5_simplify(d_solver, dt2, false);
223 : :
224 : 1 : Cvc5Term b1 = cvc5_mk_var(d_tm, bv_sort, "b1");
225 : 1 : (void)cvc5_simplify(d_solver, b1, false);
226 : 1 : Cvc5Term b2 = cvc5_mk_var(d_tm, bv_sort, "b1");
227 : 1 : (void)cvc5_simplify(d_solver, b2, false);
228 : 1 : Cvc5Term b3 = cvc5_mk_var(d_tm, d_uninterpreted, "b3");
229 : 1 : (void)cvc5_simplify(d_solver, b3, false);
230 : 1 : Cvc5Term v1 = cvc5_mk_const(d_tm, bv_sort, "v1");
231 : 1 : (void)cvc5_simplify(d_solver, v1, false);
232 : 1 : Cvc5Term v2 = cvc5_mk_const(d_tm, d_int, "v2");
233 : 1 : (void)cvc5_simplify(d_solver, v2, false);
234 : 1 : Cvc5Term f1 = cvc5_mk_const(d_tm, fun_sort1, "f1");
235 : 1 : (void)cvc5_simplify(d_solver, f1, false);
236 : 1 : Cvc5Term f2 = cvc5_mk_const(d_tm, fun_sort2, "f1");
237 : 1 : (void)cvc5_simplify(d_solver, f2, false);
238 : :
239 : 1 : std::vector<Cvc5Term> funs = {f1, f2};
240 : 1 : std::vector<size_t> nvars = {2, 1};
241 : 1 : std::vector<Cvc5Term> vars1 = {b1, b2};
242 : 1 : std::vector<Cvc5Term> vars2 = {b3};
243 : 1 : std::vector<const Cvc5Term*> vars = {vars1.data(), vars2.data()};
244 : 1 : std::vector<Cvc5Term> terms = {v1, v2};
245 : 2 : cvc5_define_funs_rec(d_solver,
246 : : funs.size(),
247 : 1 : funs.data(),
248 : : nvars.data(),
249 : : vars.data(),
250 : 1 : terms.data(),
251 : : false);
252 : 1 : (void)cvc5_simplify(d_solver, f1, false);
253 : 1 : (void)cvc5_simplify(d_solver, f2, false);
254 : :
255 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
256 : 1 : Cvc5* slv = cvc5_new(tm);
257 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
258 : : cvc5_simplify(slv, x, false),
259 : : "term is not associated with the term manager of this solver");
260 : 1 : cvc5_delete(slv);
261 : 1 : cvc5_term_manager_release(tm);
262 : 1 : cvc5_term_manager_delete(tm);
263 [ + - ]: 1 : }
264 : :
265 : 4 : TEST_F(TestCApiBlackSolver, simplify_apply_subs)
266 : : {
267 : 1 : cvc5_set_option(d_solver, "incremental", "true");
268 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
269 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
270 : 1 : std::vector<Cvc5Term> args = {x, zero};
271 : 1 : Cvc5Term eq = cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
272 : 1 : cvc5_assert_formula(d_solver, eq);
273 : 1 : cvc5_check_sat(d_solver);
274 : :
275 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(cvc5_simplify(d_solver, x, false), x));
276 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(cvc5_simplify(d_solver, x, true), zero));
277 [ + - ]: 1 : }
278 : :
279 : 4 : TEST_F(TestCApiBlackSolver, assert_formula)
280 : : {
281 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_assert_formula(nullptr, cvc5_mk_true(d_tm)),
[ - + ][ + - ]
[ + - ][ + - ]
282 : : "unexpected NULL argument");
283 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_assert_formula(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
284 : :
285 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_true(d_tm));
286 : :
287 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
288 : 1 : Cvc5* slv = cvc5_new(tm);
289 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
290 : : cvc5_assert_formula(slv, cvc5_mk_true(d_tm)),
291 : : "term is not associated with the term manager of this solver");
292 : 1 : cvc5_delete(slv);
293 : 1 : cvc5_term_manager_release(tm);
294 : 1 : cvc5_term_manager_delete(tm);
295 : : }
296 : :
297 : 4 : TEST_F(TestCApiBlackSolver, check_sat)
298 : : {
299 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_sat(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
300 : :
301 : 1 : cvc5_set_option(d_solver, "incremental", "false");
302 : 1 : cvc5_check_sat(d_solver);
303 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_sat(d_solver), "cannot make multiple queries");
[ - + ][ + - ]
[ + - ][ + - ]
304 : : }
305 : :
306 : 4 : TEST_F(TestCApiBlackSolver, check_sat_assuming)
307 : : {
308 : 1 : std::vector<Cvc5Term> assumptions = {nullptr};
309 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
310 : : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data()),
311 : : "invalid term at index 0");
312 : 1 : assumptions = {cvc5_mk_true(d_tm)};
313 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
314 : : cvc5_check_sat_assuming(nullptr, assumptions.size(), assumptions.data()),
315 : : "unexpected NULL argument");
316 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_sat_assuming(d_solver, 0, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
317 : : "unexpected NULL argument");
318 : :
319 : 1 : cvc5_set_option(d_solver, "incremental", "false");
320 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
321 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
322 : : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data()),
323 : : "cannot make multiple queries");
324 : :
325 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
326 : 1 : Cvc5* slv = cvc5_new(tm);
327 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
328 : : cvc5_check_sat_assuming(slv, assumptions.size(), assumptions.data()),
329 : : "expected a term associated with the term manager of this solver");
330 : : ;
331 : 1 : cvc5_delete(slv);
332 : 1 : cvc5_term_manager_release(tm);
333 : 1 : cvc5_term_manager_delete(tm);
334 [ + - ]: 1 : }
335 : :
336 : 4 : TEST_F(TestCApiBlackSolver, check_sat_assuming1)
337 : : {
338 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
339 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_bool, "y");
340 : 1 : std::vector<Cvc5Term> args = {x, y};
341 : 1 : Cvc5Term z = cvc5_mk_term(d_tm, CVC5_KIND_AND, args.size(), args.data());
342 : 1 : cvc5_set_option(d_solver, "incremental", "true");
343 : 1 : std::vector<Cvc5Term> assumptions = {cvc5_mk_true(d_tm)};
344 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
345 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
346 : 1 : assumptions = {z};
347 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
348 : 1 : }
349 : :
350 : 4 : TEST_F(TestCApiBlackSolver, check_sat_assuming2)
351 : : {
352 : 1 : cvc5_set_option(d_solver, "incremental", "true");
353 : :
354 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
355 : : Cvc5Sort u_to_int_sort =
356 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
357 : 1 : domain = {d_int};
358 : : Cvc5Sort int_pred_sort =
359 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
360 : :
361 : : // Constants
362 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
363 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
364 : : // Functions
365 : 1 : Cvc5Term f = cvc5_mk_const(d_tm, u_to_int_sort, "f");
366 : 1 : Cvc5Term p = cvc5_mk_const(d_tm, int_pred_sort, "p");
367 : : // Values
368 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
369 : 1 : Cvc5Term one = cvc5_mk_integer_int64(d_tm, 1);
370 : : // Terms
371 : 1 : std::vector<Cvc5Term> args = {f, x};
372 : : Cvc5Term f_x =
373 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
374 : 1 : args = {f, y};
375 : : Cvc5Term f_y =
376 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
377 : 1 : args = {f_x, f_y};
378 : 1 : Cvc5Term sum = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
379 : 1 : args = {p, zero};
380 : : Cvc5Term p_0 =
381 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
382 : 1 : args = {p, f_y};
383 : : Cvc5Term p_f_y =
384 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
385 : : // Assertions
386 : 1 : args = {zero, f_x};
387 : 1 : Cvc5Term args1 = cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data());
388 : 1 : args = {zero, f_y};
389 : 1 : Cvc5Term args2 = cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data());
390 : 1 : args = {sum, one};
391 : 1 : Cvc5Term args3 = cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data());
392 : 1 : args = {p_0};
393 : 0 : args = {args1,
394 : : args2,
395 : : args3,
396 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()),
397 : 1 : p_f_y};
398 : : Cvc5Term assertions =
399 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_AND, args.size(), args.data());
400 : :
401 : 1 : std::vector<Cvc5Term> assumptions = {cvc5_mk_true(d_tm)};
402 : 1 : (void)cvc5_check_sat_assuming(
403 : 1 : d_solver, assumptions.size(), assumptions.data());
404 : 1 : cvc5_assert_formula(d_solver, assertions);
405 : 1 : args = {x, y};
406 : : Cvc5Term dist =
407 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_DISTINCT, args.size(), args.data());
408 : 1 : assumptions = {dist};
409 : 1 : (void)cvc5_check_sat_assuming(
410 : 1 : d_solver, assumptions.size(), assumptions.data());
411 : 1 : assumptions = {cvc5_mk_false(d_tm), dist};
412 : 1 : }
413 : :
414 : 4 : TEST_F(TestCApiBlackSolver, declare_datatype)
415 : : {
416 : 1 : Cvc5DatatypeConstructorDecl nil = cvc5_mk_dt_cons_decl(d_tm, "lin");
417 : 1 : std::vector<Cvc5DatatypeConstructorDecl> ctors = {nil};
418 : 1 : (void)cvc5_declare_dt(d_solver, "", ctors.size(), ctors.data());
419 : :
420 : 1 : nil = cvc5_mk_dt_cons_decl(d_tm, "nil");
421 : 1 : ctors = {nil};
422 : 1 : (void)cvc5_declare_dt(d_solver, "a", ctors.size(), ctors.data());
423 : :
424 : 1 : Cvc5DatatypeConstructorDecl cons = cvc5_mk_dt_cons_decl(d_tm, "cons");
425 : 1 : nil = cvc5_mk_dt_cons_decl(d_tm, "nil");
426 : 1 : ctors = {cons, nil};
427 : 1 : (void)cvc5_declare_dt(d_solver, "b", ctors.size(), ctors.data());
428 : :
429 : 1 : cons = cvc5_mk_dt_cons_decl(d_tm, "cons");
430 : 1 : nil = cvc5_mk_dt_cons_decl(d_tm, "nil");
431 : 1 : ctors = {cons, nil};
432 : 1 : (void)cvc5_declare_dt(d_solver, "", ctors.size(), ctors.data());
433 : :
434 : 1 : cons = cvc5_mk_dt_cons_decl(d_tm, "cons");
435 : 1 : nil = cvc5_mk_dt_cons_decl(d_tm, "nil");
436 : 1 : ctors = {cons, nil};
437 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_dt(nullptr, "c", ctors.size(), ctors.data()),
[ - + ][ + - ]
[ + - ][ + - ]
438 : : "unexpected NULL argument");
439 : 1 : ctors = {nullptr};
440 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_dt(d_solver, "c", ctors.size(), ctors.data()),
[ - + ][ + - ]
[ + - ][ + - ]
441 : : "invalid datatype constructor declaration at index 0");
442 : :
443 : : // must have at least one constructor
444 : 1 : ctors = {};
445 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
446 : : cvc5_declare_dt(d_solver, "c", ctors.size(), ctors.data()),
447 : : "expected a datatype declaration with at least one constructor");
448 : : // constructors may not be reused
449 : 1 : Cvc5DatatypeConstructorDecl ctor1 = cvc5_mk_dt_cons_decl(d_tm, "_x21");
450 : 1 : Cvc5DatatypeConstructorDecl ctor2 = cvc5_mk_dt_cons_decl(d_tm, "_x31");
451 : 1 : ctors = {ctor1, ctor2};
452 : 1 : (void)cvc5_declare_dt(d_solver, "_x17", ctors.size(), ctors.data());
453 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
454 : : cvc5_declare_dt(d_solver, "_x86", ctors.size(), ctors.data()),
455 : : "cannot use a constructor for multiple datatypes");
456 : :
457 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
458 : 1 : Cvc5* slv = cvc5_new(tm);
459 : 1 : nil = cvc5_mk_dt_cons_decl(d_tm, "nil");
460 : 1 : ctors = {nil};
461 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
462 : : cvc5_declare_dt(slv, "a", ctors.size(), ctors.data()),
463 : : "expected a datatype constructor declaration associated with "
464 : : "the term manager of this solver");
465 : 1 : cvc5_delete(slv);
466 : 1 : cvc5_term_manager_release(tm);
467 : 1 : cvc5_term_manager_delete(tm);
468 [ + - ]: 1 : }
469 : :
470 : 4 : TEST_F(TestCApiBlackSolver, dt_get_arity)
471 : : {
472 : : std::vector<Cvc5DatatypeConstructorDecl> ctors = {
473 : 1 : cvc5_mk_dt_cons_decl(d_tm, "_x21"), cvc5_mk_dt_cons_decl(d_tm, "_x31")};
474 : 1 : Cvc5Sort s3 = cvc5_declare_dt(d_solver, "_x17", ctors.size(), ctors.data());
475 [ - + ][ + - ]: 1 : ASSERT_EQ(cvc5_sort_dt_get_arity(s3), 0);
476 [ + - ]: 1 : }
477 : :
478 : 4 : TEST_F(TestCApiBlackSolver, declare_fun)
479 : : {
480 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_fun(nullptr, "b", 0, nullptr, d_bool, true),
[ - + ][ + - ]
[ + - ][ + - ]
481 : : "unexpected NULL argument");
482 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_fun(d_solver, "b", 0, nullptr, nullptr, true),
[ - + ][ + - ]
[ + - ][ + - ]
483 : : "invalid sort");
484 : :
485 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
486 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
487 : : Cvc5Sort fun_sort =
488 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
489 : 1 : (void)cvc5_declare_fun(d_solver, "f1", 0, nullptr, bv_sort, true);
490 : 1 : domain = {bv_sort, d_int};
491 : 1 : (void)cvc5_declare_fun(
492 : 1 : d_solver, "f3", domain.size(), domain.data(), bv_sort, true);
493 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
494 : : cvc5_declare_fun(d_solver, "f3", 0, nullptr, fun_sort, true),
495 : : "invalid argument");
496 : : // functions as arguments is allowed
497 : 1 : domain = {bv_sort, fun_sort};
498 : 1 : (void)cvc5_declare_fun(
499 : 1 : d_solver, "f4", domain.size(), domain.data(), bv_sort, true);
500 : 1 : domain = {bv_sort, bv_sort};
501 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
502 : : cvc5_declare_fun(
503 : : d_solver, "f5", domain.size(), domain.data(), fun_sort, true),
504 : : "invalid argument");
505 : :
506 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
507 : 1 : Cvc5* slv = cvc5_new(tm);
508 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
509 : : cvc5_declare_fun(slv, "f1", 0, nullptr, bv_sort, true),
510 : : "sort is not associated with the term manager of this solver");
511 : 1 : cvc5_delete(slv);
512 : 1 : cvc5_term_manager_release(tm);
513 : 1 : cvc5_term_manager_delete(tm);
514 : : }
515 : :
516 : 4 : TEST_F(TestCApiBlackSolver, declare_fun_fresh)
517 : : {
518 : : // std::vector<Cvc5Sort> domain =
519 : 1 : Cvc5Term t1 = cvc5_declare_fun(d_solver, "b", 0, nullptr, d_bool, true);
520 : 1 : Cvc5Term t2 = cvc5_declare_fun(d_solver, "b", 0, nullptr, d_bool, false);
521 : 1 : Cvc5Term t3 = cvc5_declare_fun(d_solver, "b", 0, nullptr, d_bool, false);
522 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_term_is_equal(t1, t2));
523 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_term_is_equal(t1, t3));
524 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(t2, t3));
525 : 1 : Cvc5Term t4 = cvc5_declare_fun(d_solver, "c", 0, nullptr, d_bool, false);
526 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_term_is_equal(t2, t4));
527 : 1 : Cvc5Term t5 = cvc5_declare_fun(d_solver, "b", 0, nullptr, d_int, false);
528 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_term_is_equal(t2, t5));
529 : :
530 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
531 : 1 : Cvc5* slv = cvc5_new(tm);
532 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
533 : : cvc5_declare_fun(slv, "b", 0, nullptr, d_int, false),
534 : : "sort is not associated with the term manager of this solver");
535 : : ;
536 : 1 : cvc5_delete(slv);
537 : 1 : cvc5_term_manager_release(tm);
538 : 1 : cvc5_term_manager_delete(tm);
539 : : }
540 : :
541 : 4 : TEST_F(TestCApiBlackSolver, declare_sort)
542 : : {
543 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sort(nullptr, "s", 0, true),
[ - + ][ + - ]
[ + - ][ + - ]
544 : : "unexpected NULL argument");
545 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sort(d_solver, nullptr, 0, true),
[ - + ][ + - ]
[ + - ][ + - ]
546 : : "unexpected NULL argument");
547 : 1 : (void)cvc5_declare_sort(d_solver, "s", 0, true);
548 : 1 : (void)cvc5_declare_sort(d_solver, "s", 2, true);
549 : 1 : (void)cvc5_declare_sort(d_solver, "", 2, true);
550 : : }
551 : :
552 : 4 : TEST_F(TestCApiBlackSolver, declare_sort_fresh)
553 : : {
554 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sort(nullptr, "b", 0, true),
[ - + ][ + - ]
[ + - ][ + - ]
555 : : "unexpected NULL argument");
556 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sort(d_solver, nullptr, 0, true),
[ - + ][ + - ]
[ + - ][ + - ]
557 : : "unexpected NULL argument");
558 : :
559 : 1 : Cvc5Sort s1 = cvc5_declare_sort(d_solver, "b", 0, true);
560 : 1 : Cvc5Sort s2 = cvc5_declare_sort(d_solver, "b", 0, false);
561 : 1 : Cvc5Sort s3 = cvc5_declare_sort(d_solver, "b", 0, false);
562 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_sort_is_equal(s1, s2));
563 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_sort_is_equal(s1, s3));
564 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_sort_is_equal(s2, s3));
565 : :
566 : 1 : Cvc5Sort s4 = cvc5_declare_sort(d_solver, "c", 0, false);
567 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_sort_is_equal(s2, s4));
568 : :
569 : 1 : Cvc5Sort s5 = cvc5_declare_sort(d_solver, "b", 1, false);
570 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_sort_is_equal(s2, s5));
571 : : }
572 : :
573 : 4 : TEST_F(TestCApiBlackSolver, define_fun)
574 : : {
575 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
576 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
577 : : Cvc5Sort fun_sort =
578 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
579 : :
580 : 1 : Cvc5Term b1 = cvc5_mk_var(d_tm, bv_sort, "b1");
581 : 1 : Cvc5Term b2 = cvc5_mk_var(d_tm, d_int, "b2");
582 : 1 : Cvc5Term b3 = cvc5_mk_var(d_tm, fun_sort, "b3");
583 : 1 : Cvc5Term v1 = cvc5_mk_const(d_tm, bv_sort, "v1");
584 : 1 : Cvc5Term v2 = cvc5_mk_const(d_tm, fun_sort, "v2");
585 : :
586 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
587 : : cvc5_define_fun(nullptr, "f", 0, nullptr, bv_sort, v1, false),
588 : : "unexpected NULL argument");
589 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
590 : : cvc5_define_fun(d_solver, "f", 0, nullptr, nullptr, v1, false),
591 : : "invalid sort");
592 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
593 : : cvc5_define_fun(d_solver, "f", 0, nullptr, bv_sort, nullptr, false),
594 : : "invalid term");
595 : :
596 : 1 : (void)cvc5_define_fun(d_solver, "f", 0, nullptr, bv_sort, v1, false);
597 : 1 : std::vector<Cvc5Term> vars = {b1, b2};
598 : 1 : (void)cvc5_define_fun(
599 : 1 : d_solver, "f", vars.size(), vars.data(), bv_sort, v1, false);
600 : 1 : vars = {v1, b2};
601 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
602 : : cvc5_define_fun(
603 : : d_solver, "f", vars.size(), vars.data(), bv_sort, v1, false),
604 : : "invalid bound variable");
605 : 1 : vars = {b1};
606 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
607 : : cvc5_define_fun(
608 : : d_solver, "f", vars.size(), vars.data(), bv_sort, v2, false),
609 : : "invalid sort of function body");
610 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
611 : : cvc5_define_fun(
612 : : d_solver, "f", vars.size(), vars.data(), fun_sort, v2, false),
613 : : "invalid argument");
614 : : // b3 has function sort, which is allowed as an argument
615 : 1 : vars = {b1, b3};
616 : 1 : (void)cvc5_define_fun(
617 : 1 : d_solver, "f", vars.size(), vars.data(), bv_sort, v1, false);
618 : :
619 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
620 : 1 : Cvc5* slv = cvc5_new(tm);
621 : 1 : Cvc5Sort bv_sort2 = cvc5_mk_bv_sort(tm, 32);
622 : 1 : Cvc5Term v12 = cvc5_mk_const(tm, bv_sort2, "v1");
623 : 1 : Cvc5Term b12 = cvc5_mk_var(tm, bv_sort2, "b1");
624 : 1 : Cvc5Term b22 = cvc5_mk_var(tm, cvc5_get_integer_sort(tm), "b2");
625 : 1 : vars = {};
626 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
627 : : cvc5_define_fun(slv, "f", vars.size(), vars.data(), bv_sort, v12, false),
628 : : "sort is not associated with the term manager of this solver");
629 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
630 : : cvc5_define_fun(slv, "f", vars.size(), vars.data(), bv_sort2, v1, false),
631 : : "term is not associated with the term manager of this solver");
632 : 1 : vars = {b1, b22};
633 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
634 : : cvc5_define_fun(slv, "f", vars.size(), vars.data(), bv_sort2, v12, false),
635 : : "expected a term associated with the term manager of this solver");
636 : 1 : vars = {b12, b2};
637 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
638 : : cvc5_define_fun(slv, "f", vars.size(), vars.data(), bv_sort2, v12, false),
639 : : "expected a term associated with the term manager of this solver");
640 : 1 : vars = {b12, b22};
641 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
642 : : cvc5_define_fun(slv, "f", vars.size(), vars.data(), bv_sort, v12, false),
643 : : "sort is not associated with the term manager of this solver");
644 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
645 : : cvc5_define_fun(slv, "f", vars.size(), vars.data(), bv_sort2, v1, false),
646 : : "term is not associated with the term manager of this solver");
647 : 1 : cvc5_delete(slv);
648 : 1 : cvc5_term_manager_release(tm);
649 : 1 : cvc5_term_manager_delete(tm);
650 [ + - ]: 1 : }
651 : :
652 : 4 : TEST_F(TestCApiBlackSolver, define_fun_global)
653 : : {
654 : 1 : Cvc5Term btrue = cvc5_mk_true(d_tm);
655 : : // (define-fun f () Bool true)
656 : 1 : Cvc5Term f = cvc5_define_fun(d_solver, "f", 0, nullptr, d_bool, btrue, true);
657 : 1 : Cvc5Term b = cvc5_mk_var(d_tm, d_bool, "b");
658 : : // (define-fun g (b Bool) Bool b)
659 : 1 : std::vector<Cvc5Term> vars = {b};
660 : : Cvc5Term g =
661 : 1 : cvc5_define_fun(d_solver, "g", vars.size(), vars.data(), d_bool, b, true);
662 : :
663 : : // (assert (or (not f) (not (g true))))
664 : 1 : std::vector<Cvc5Term> args = {f};
665 : 1 : Cvc5Term fnot = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
666 : 1 : args = {g, btrue};
667 : : Cvc5Term app =
668 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
669 : 1 : args = {app};
670 : 1 : Cvc5Term appnot = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
671 : :
672 : 1 : args = {fnot, appnot};
673 : 1 : cvc5_assert_formula(
674 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
675 : 1 : Cvc5Result res = cvc5_check_sat(d_solver);
676 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
677 : :
678 : 1 : cvc5_reset_assertions(d_solver);
679 : 1 : cvc5_result_release(res);
680 : : // (assert (or (not f) (not (g true))))
681 : 1 : cvc5_assert_formula(
682 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
683 : 1 : res = cvc5_check_sat(d_solver);
684 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
685 [ + - ][ + - ]: 1 : }
686 : :
687 : 4 : TEST_F(TestCApiBlackSolver, define_fun_rec)
688 : : {
689 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
690 : 1 : std::vector<Cvc5Sort> domain = {bv_sort, bv_sort};
691 : : Cvc5Sort fun_sort1 =
692 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), bv_sort);
693 : 1 : domain = {d_uninterpreted};
694 : : Cvc5Sort fun_sort2 =
695 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
696 : :
697 : 1 : Cvc5Term b1 = cvc5_mk_var(d_tm, bv_sort, "b1");
698 : 1 : Cvc5Term b11 = cvc5_mk_var(d_tm, bv_sort, "b1");
699 : 1 : Cvc5Term b2 = cvc5_mk_var(d_tm, d_int, "b2");
700 : 1 : Cvc5Term b3 = cvc5_mk_var(d_tm, fun_sort2, "b3");
701 : 1 : Cvc5Term v1 = cvc5_mk_const(d_tm, bv_sort, "v1");
702 : 1 : Cvc5Term v2 = cvc5_mk_const(d_tm, d_int, "v1");
703 : 1 : Cvc5Term v3 = cvc5_mk_const(d_tm, fun_sort2, "v3");
704 : 1 : Cvc5Term f1 = cvc5_mk_const(d_tm, fun_sort1, "f1");
705 : 1 : Cvc5Term f2 = cvc5_mk_const(d_tm, fun_sort2, "f2");
706 : 1 : Cvc5Term f3 = cvc5_mk_const(d_tm, bv_sort, "f3");
707 : :
708 : 1 : (void)cvc5_define_fun_rec(d_solver, "f", 0, nullptr, bv_sort, v1, false);
709 : 1 : std::vector<Cvc5Term> vars = {b1, b2};
710 : 1 : (void)cvc5_define_fun_rec(
711 : 1 : d_solver, "f", vars.size(), vars.data(), bv_sort, v1, false);
712 : 1 : vars = {b1, b11};
713 : 1 : (void)cvc5_define_fun_rec_from_const(
714 : 1 : d_solver, f1, vars.size(), vars.data(), v1, false);
715 : :
716 : : // b3 has function sort, which is allowed as an argument
717 : 1 : vars = {b1, b3};
718 : 1 : (void)cvc5_define_fun_rec(
719 : 1 : d_solver, "f", vars.size(), vars.data(), bv_sort, v1, false);
720 : :
721 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
722 : : cvc5_define_fun_rec(nullptr, "f", 0, nullptr, bv_sort, v1, false),
723 : : "unexpected NULL argument");
724 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
725 : : cvc5_define_fun_rec(d_solver, nullptr, 0, nullptr, bv_sort, v1, false),
726 : : "unexpected NULL argument");
727 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
728 : : cvc5_define_fun_rec(d_solver, "f", 0, nullptr, nullptr, v1, false),
729 : : "invalid sort");
730 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
731 : : cvc5_define_fun_rec(d_solver, "f", 0, nullptr, bv_sort, nullptr, false),
732 : : "invalid term");
733 : :
734 : 1 : vars = {b1};
735 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
736 : : cvc5_define_fun_rec(
737 : : d_solver, "f", vars.size(), vars.data(), bv_sort, v3, false),
738 : : "invalid sort");
739 : 1 : vars = {b1, v2};
740 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
741 : : cvc5_define_fun_rec(
742 : : d_solver, "f", vars.size(), vars.data(), bv_sort, v1, false),
743 : : "invalid bound variable");
744 : 1 : vars = {b1};
745 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
746 : : cvc5_define_fun_rec(
747 : : d_solver, "f", vars.size(), vars.data(), fun_sort2, v3, false),
748 : : "invalid argument");
749 : :
750 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
751 : : cvc5_define_fun_rec_from_const(nullptr, f1, 0, nullptr, v1, false),
752 : : "unexpected NULL argument");
753 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
754 : : cvc5_define_fun_rec_from_const(d_solver, nullptr, 0, nullptr, v1, false),
755 : : "invalid term");
756 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
757 : : cvc5_define_fun_rec_from_const(d_solver, f1, 0, nullptr, nullptr, false),
758 : : "invalid term");
759 : :
760 : 1 : vars = {b1};
761 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_fun_rec_from_const(
[ - + ][ + - ]
[ + - ][ + - ]
762 : : d_solver, f1, vars.size(), vars.data(), v1, false),
763 : : "invalid size of argument 'bound_vars'");
764 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_fun_rec_from_const(
[ - + ][ + - ]
[ + - ][ + - ]
765 : : d_solver, f2, vars.size(), vars.data(), v2, false),
766 : : "invalid sort");
767 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_fun_rec_from_const(
[ - + ][ + - ]
[ + - ][ + - ]
768 : : d_solver, f3, vars.size(), vars.data(), v1, false),
769 : : "invalid argument");
770 : 1 : vars = {b1, b11};
771 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_fun_rec_from_const(
[ - + ][ + - ]
[ + - ][ + - ]
772 : : d_solver, f1, vars.size(), vars.data(), v2, false),
773 : : "invalid sort");
774 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_fun_rec_from_const(
[ - + ][ + - ]
[ + - ][ + - ]
775 : : d_solver, f1, vars.size(), vars.data(), v3, false),
776 : : "invalid sort");
777 : :
778 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
779 : 1 : Cvc5* slv = cvc5_new(tm);
780 : 1 : Cvc5Sort bv_sort2 = cvc5_mk_bv_sort(tm, 32);
781 : 1 : Cvc5Term b12 = cvc5_mk_var(tm, bv_sort2, "b1");
782 : 1 : Cvc5Term b22 = cvc5_mk_var(tm, cvc5_get_integer_sort(tm), "b2");
783 : 1 : Cvc5Term v12 = cvc5_mk_const(tm, bv_sort2, "v1");
784 : 1 : vars = {};
785 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
786 : : cvc5_define_fun_rec(
787 : : d_solver, "f", vars.size(), vars.data(), bv_sort2, v12, false),
788 : : "term is not associated with the term manager of this solver");
789 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
790 : : cvc5_define_fun_rec(
791 : : slv, "f", vars.size(), vars.data(), bv_sort, v12, false),
792 : : "sort is not associated with the term manager of this solver");
793 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
794 : : cvc5_define_fun_rec(
795 : : slv, "f", vars.size(), vars.data(), bv_sort2, v1, false),
796 : : "term is not associated with the term manager of this solver");
797 : 1 : vars = {b12, b22};
798 : 1 : (void)cvc5_define_fun_rec(
799 : 1 : slv, "f", vars.size(), vars.data(), bv_sort2, v12, false);
800 : 1 : vars = {b1, b22};
801 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
802 : : cvc5_define_fun_rec(
803 : : slv, "f", vars.size(), vars.data(), bv_sort2, v12, false),
804 : : "expected a term associated with the term manager of this solver");
805 : 1 : vars = {b12, b2};
806 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
807 : : cvc5_define_fun_rec(
808 : : slv, "f", vars.size(), vars.data(), bv_sort2, v12, false),
809 : : "expected a term associated with the term manager of this solver");
810 : 1 : cvc5_delete(slv);
811 : 1 : cvc5_term_manager_release(tm);
812 : 1 : cvc5_term_manager_delete(tm);
813 [ + - ][ + - ]: 1 : }
814 : :
815 : 4 : TEST_F(TestCApiBlackSolver, define_fun_rec_wrong_logic)
816 : : {
817 : 1 : cvc5_set_logic(d_solver, "QF_BV");
818 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
819 : 1 : std::vector<Cvc5Sort> domain = {bv_sort, bv_sort};
820 : : Cvc5Sort fun_sort =
821 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), bv_sort);
822 : 1 : Cvc5Term b = cvc5_mk_var(d_tm, bv_sort, "b");
823 : 1 : Cvc5Term v = cvc5_mk_var(d_tm, bv_sort, "v");
824 : 1 : Cvc5Term f = cvc5_mk_var(d_tm, fun_sort, "f");
825 : 1 : std::vector<Cvc5Term> vars = {};
826 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
827 : : cvc5_define_fun_rec(
828 : : d_solver, "f", vars.size(), vars.data(), bv_sort, v, false),
829 : : "require a logic with quantifiers");
830 : 1 : vars = {b, b};
831 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_fun_rec_from_const(
[ - + ][ + - ]
[ + - ][ + - ]
832 : : d_solver, f, vars.size(), vars.data(), v, false),
833 : : "require a logic with quantifiers");
834 [ + - ][ + - ]: 1 : }
835 : :
836 : 4 : TEST_F(TestCApiBlackSolver, define_fun_rec_global)
837 : : {
838 : 1 : cvc5_push(d_solver, 1);
839 : 1 : Cvc5Term btrue = cvc5_mk_true(d_tm);
840 : : // (define-fun f () Bool true)
841 : : Cvc5Term f =
842 : 1 : cvc5_define_fun_rec(d_solver, "f", 0, nullptr, d_bool, btrue, true);
843 : 1 : Cvc5Term b = cvc5_mk_var(d_tm, d_bool, "b");
844 : : // (define-fun g (b Bool) Bool b)
845 : 1 : std::vector<Cvc5Sort> domain = {d_bool};
846 : 1 : Cvc5Term ff = cvc5_mk_const(
847 : 1 : d_tm, cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool), "g");
848 : 1 : std::vector<Cvc5Term> vars = {b};
849 : 1 : Cvc5Term g = cvc5_define_fun_rec_from_const(
850 : 1 : d_solver, ff, vars.size(), vars.data(), b, true);
851 : :
852 : : // (assert (or (not f) (not (g true))))
853 : 1 : std::vector<Cvc5Term> args = {f};
854 : 1 : Cvc5Term fnot = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
855 : 1 : args = {g, btrue};
856 : : Cvc5Term app =
857 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
858 : 1 : args = {app};
859 : 1 : Cvc5Term appnot = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
860 : 1 : args = {fnot, appnot};
861 : 1 : cvc5_assert_formula(
862 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
863 : 1 : Cvc5Result res = cvc5_check_sat(d_solver);
864 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
865 : 1 : cvc5_pop(d_solver, 1);
866 : : // (assert (or (not f) (not (g true))))
867 : 1 : cvc5_assert_formula(
868 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
869 : 1 : res = cvc5_check_sat(d_solver);
870 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
871 : :
872 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
873 : 1 : Cvc5* slv = cvc5_new(tm);
874 : 1 : Cvc5Term bb = cvc5_mk_var(tm, cvc5_get_boolean_sort(tm), "b");
875 : 1 : domain = {d_bool};
876 : 1 : vars = {bb};
877 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
878 : : cvc5_define_fun_rec_from_const(
879 : : slv,
880 : : cvc5_mk_const(
881 : : d_tm,
882 : : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool),
883 : : "g"),
884 : : vars.size(),
885 : : vars.data(),
886 : : bb,
887 : : true),
888 : : "term is not associated with the term manager of this solver");
889 : 1 : vars = {b};
890 : 1 : domain = {cvc5_get_boolean_sort(tm)};
891 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
892 : : cvc5_define_fun_rec_from_const(
893 : : slv,
894 : : cvc5_mk_const(
895 : : tm,
896 : : cvc5_mk_fun_sort(
897 : : tm, domain.size(), domain.data(), cvc5_get_boolean_sort(tm)),
898 : : "g"),
899 : : vars.size(),
900 : : vars.data(),
901 : : bb,
902 : : true),
903 : : "invalid sort of parameter");
904 : 1 : cvc5_delete(slv);
905 : 1 : cvc5_term_manager_release(tm);
906 : 1 : cvc5_term_manager_delete(tm);
907 [ + - ][ + - ]: 1 : }
[ + - ]
908 : :
909 : 4 : TEST_F(TestCApiBlackSolver, define_funs_rec)
910 : : {
911 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
912 : 1 : std::vector<Cvc5Sort> domain = {bv_sort, bv_sort};
913 : : Cvc5Sort fun_sort1 =
914 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), bv_sort);
915 : 1 : domain = {d_uninterpreted};
916 : : Cvc5Sort fun_sort2 =
917 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
918 : 1 : Cvc5Term b1 = cvc5_mk_var(d_tm, bv_sort, "b1");
919 : 1 : Cvc5Term b11 = cvc5_mk_var(d_tm, bv_sort, "b1");
920 : 1 : Cvc5Term b2 = cvc5_mk_var(d_tm, d_int, "b2");
921 : 1 : Cvc5Term b4 = cvc5_mk_var(d_tm, d_uninterpreted, "b4");
922 : 1 : Cvc5Term v1 = cvc5_mk_const(d_tm, bv_sort, "v1");
923 : 1 : Cvc5Term v2 = cvc5_mk_const(d_tm, d_int, "v2");
924 : 1 : Cvc5Term v4 = cvc5_mk_const(d_tm, d_uninterpreted, "v4");
925 : 1 : Cvc5Term f1 = cvc5_mk_const(d_tm, fun_sort1, "f1");
926 : 1 : Cvc5Term f2 = cvc5_mk_const(d_tm, fun_sort2, "f2");
927 : 1 : Cvc5Term f3 = cvc5_mk_const(d_tm, bv_sort, "f3");
928 : :
929 : 1 : std::vector<Cvc5Term> funs = {f1, f2};
930 : 1 : std::vector<size_t> nvars = {2, 1};
931 : 1 : std::vector<Cvc5Term> vars1 = {b1, b11};
932 : 1 : std::vector<Cvc5Term> vars2 = {b4};
933 : 1 : std::vector<const Cvc5Term*> vars = {vars1.data(), vars2.data()};
934 : 1 : std::vector<Cvc5Term> terms = {v1, v2};
935 : :
936 : 2 : cvc5_define_funs_rec(d_solver,
937 : : funs.size(),
938 : 1 : funs.data(),
939 : : nvars.data(),
940 : : vars.data(),
941 : 1 : terms.data(),
942 : : false);
943 : 1 : vars1 = {v1, b11};
944 : 1 : vars = {vars1.data(), vars2.data()};
945 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_funs_rec(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
946 : : funs.size(),
947 : : funs.data(),
948 : : nvars.data(),
949 : : vars.data(),
950 : : terms.data(),
951 : : false),
952 : : "invalid bound variable");
953 : 1 : funs = {f1, f3};
954 : 1 : vars1 = {b1, b11};
955 : 1 : vars = {vars1.data(), vars2.data()};
956 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_funs_rec(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
957 : : funs.size(),
958 : : funs.data(),
959 : : nvars.data(),
960 : : vars.data(),
961 : : terms.data(),
962 : : false),
963 : : "invalid argument");
964 : 1 : funs = {f1, f2};
965 : 1 : vars1 = {b1};
966 : 1 : vars = {vars1.data(), vars2.data()};
967 : 1 : nvars = {1, 1};
968 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_funs_rec(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
969 : : funs.size(),
970 : : funs.data(),
971 : : nvars.data(),
972 : : vars.data(),
973 : : terms.data(),
974 : : false),
975 : : "invalid size of argument");
976 : 1 : vars1 = {b1, b2};
977 : 1 : vars = {vars1.data(), vars2.data()};
978 : 1 : nvars = {2, 1};
979 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_funs_rec(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
980 : : funs.size(),
981 : : funs.data(),
982 : : nvars.data(),
983 : : vars.data(),
984 : : terms.data(),
985 : : false),
986 : : "invalid sort");
987 : 1 : vars1 = {b1, b11};
988 : 1 : vars = {vars1.data(), vars2.data()};
989 : 1 : terms = {v1, v4};
990 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_funs_rec(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
991 : : funs.size(),
992 : : funs.data(),
993 : : nvars.data(),
994 : : vars.data(),
995 : : terms.data(),
996 : : false),
997 : : "invalid sort");
998 : :
999 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
1000 : 1 : Cvc5* slv = cvc5_new(tm);
1001 : 1 : Cvc5Sort uninterpreted2 = cvc5_mk_uninterpreted_sort(tm, "u");
1002 : 1 : Cvc5Sort bv_sort2 = cvc5_mk_bv_sort(tm, 32);
1003 : :
1004 : 1 : domain = {bv_sort2, bv_sort2};
1005 : : Cvc5Sort fun_sort12 =
1006 : 1 : cvc5_mk_fun_sort(tm, domain.size(), domain.data(), bv_sort2);
1007 : 1 : domain = {uninterpreted2};
1008 : 2 : Cvc5Sort fun_sort22 = cvc5_mk_fun_sort(
1009 : 1 : tm, domain.size(), domain.data(), cvc5_get_integer_sort(tm));
1010 : :
1011 : 1 : Cvc5Term b12 = cvc5_mk_var(tm, bv_sort2, "b1");
1012 : 1 : Cvc5Term b112 = cvc5_mk_var(tm, bv_sort2, "b1");
1013 : 1 : Cvc5Term b42 = cvc5_mk_var(tm, uninterpreted2, "b4");
1014 : 1 : Cvc5Term v12 = cvc5_mk_const(tm, bv_sort2, "v1");
1015 : 1 : Cvc5Term v22 = cvc5_mk_const(tm, cvc5_get_integer_sort(tm), "v2");
1016 : 1 : Cvc5Term f12 = cvc5_mk_const(tm, fun_sort12, "f1");
1017 : 1 : Cvc5Term f22 = cvc5_mk_const(tm, fun_sort22, "f2");
1018 : :
1019 : 1 : funs = {f12, f22};
1020 : 1 : nvars = {2, 1};
1021 : 1 : vars1 = {b12, b112};
1022 : 1 : vars2 = {b42};
1023 : 1 : vars = {vars1.data(), vars2.data()};
1024 : 1 : terms = {v12, v22};
1025 : 2 : cvc5_define_funs_rec(slv,
1026 : : funs.size(),
1027 : 1 : funs.data(),
1028 : : nvars.data(),
1029 : : vars.data(),
1030 : 1 : terms.data(),
1031 : : false);
1032 : 1 : funs = {f1, f22};
1033 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1034 : : cvc5_define_funs_rec(slv,
1035 : : funs.size(),
1036 : : funs.data(),
1037 : : nvars.data(),
1038 : : vars.data(),
1039 : : terms.data(),
1040 : : false),
1041 : : "expected a term associated with the term manager of this solver");
1042 : 1 : funs = {f12, f22};
1043 : 1 : vars1 = {b1, b112};
1044 : 1 : vars = {vars1.data(), vars2.data()};
1045 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1046 : : cvc5_define_funs_rec(slv,
1047 : : funs.size(),
1048 : : funs.data(),
1049 : : nvars.data(),
1050 : : vars.data(),
1051 : : terms.data(),
1052 : : false),
1053 : : "expected a term associated with the term manager of this solver");
1054 : 1 : vars1 = {b12, b11};
1055 : 1 : vars = {vars1.data(), vars2.data()};
1056 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1057 : : cvc5_define_funs_rec(slv,
1058 : : funs.size(),
1059 : : funs.data(),
1060 : : nvars.data(),
1061 : : vars.data(),
1062 : : terms.data(),
1063 : : false),
1064 : : "expected a term associated with the term manager of this solver");
1065 : 1 : vars2 = {b42};
1066 : 1 : vars = {vars1.data(), vars2.data()};
1067 : 1 : terms = {v1, v22};
1068 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1069 : : cvc5_define_funs_rec(slv,
1070 : : funs.size(),
1071 : : funs.data(),
1072 : : nvars.data(),
1073 : : vars.data(),
1074 : : terms.data(),
1075 : : false),
1076 : : "expected a term associated with the term manager of this solver");
1077 : 1 : terms = {v12, v2};
1078 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1079 : : cvc5_define_funs_rec(slv,
1080 : : funs.size(),
1081 : : funs.data(),
1082 : : nvars.data(),
1083 : : vars.data(),
1084 : : terms.data(),
1085 : : false),
1086 : : "expected a term associated with the term manager of this solver");
1087 : 1 : cvc5_delete(slv);
1088 : 1 : cvc5_term_manager_release(tm);
1089 : 1 : cvc5_term_manager_delete(tm);
1090 [ + - ][ + - ]: 1 : }
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
1091 : :
1092 : 4 : TEST_F(TestCApiBlackSolver, define_funs_rec_wrong_logic)
1093 : : {
1094 : 1 : cvc5_set_logic(d_solver, "QF_BV");
1095 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 32);
1096 : 1 : std::vector<Cvc5Sort> domain = {bv_sort, bv_sort};
1097 : : Cvc5Sort fun_sort1 =
1098 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), bv_sort);
1099 : 1 : domain = {d_uninterpreted};
1100 : : Cvc5Sort fun_sort2 =
1101 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
1102 : 1 : Cvc5Term b = cvc5_mk_var(d_tm, bv_sort, "b");
1103 : 1 : Cvc5Term u = cvc5_mk_var(d_tm, d_uninterpreted, "u");
1104 : 1 : Cvc5Term v1 = cvc5_mk_const(d_tm, bv_sort, "v1");
1105 : 1 : Cvc5Term v2 = cvc5_mk_const(d_tm, d_int, "v2");
1106 : 1 : Cvc5Term f1 = cvc5_mk_const(d_tm, fun_sort1, "f1");
1107 : 1 : Cvc5Term f2 = cvc5_mk_const(d_tm, fun_sort2, "f2");
1108 : :
1109 : 1 : std::vector<Cvc5Term> funs = {f1, f2};
1110 : 1 : std::vector<size_t> nvars = {2, 1};
1111 : 1 : std::vector<Cvc5Term> vars1 = {b, b};
1112 : 1 : std::vector<Cvc5Term> vars2 = {u};
1113 : 1 : std::vector<const Cvc5Term*> vars = {vars1.data(), vars2.data()};
1114 : 1 : std::vector<Cvc5Term> terms = {v1, v2};
1115 : :
1116 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_define_funs_rec(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
1117 : : funs.size(),
1118 : : funs.data(),
1119 : : nvars.data(),
1120 : : vars.data(),
1121 : : terms.data(),
1122 : : false),
1123 : : "require a logic with quantifiers");
1124 [ + - ][ + - ]: 1 : }
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
1125 : :
1126 : 4 : TEST_F(TestCApiBlackSolver, define_funs_rec_global)
1127 : : {
1128 : 1 : std::vector<Cvc5Sort> domain = {d_bool};
1129 : : Cvc5Sort fun_sort =
1130 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
1131 : 1 : cvc5_push(d_solver, 1);
1132 : :
1133 : 1 : Cvc5Term btrue = cvc5_mk_true(d_tm);
1134 : 1 : Cvc5Term b = cvc5_mk_var(d_tm, d_bool, "b");
1135 : 1 : Cvc5Term g = cvc5_mk_const(d_tm, fun_sort, "g");
1136 : : // (define-funs-rec ((g ((b Bool)) Bool)) (b))
1137 : 1 : std::vector<Cvc5Term> funs = {g};
1138 : 1 : std::vector<size_t> nvars = {1};
1139 : 1 : std::vector<Cvc5Term> vars1 = {b};
1140 : 1 : std::vector<const Cvc5Term*> vars = {vars1.data()};
1141 : 1 : std::vector<Cvc5Term> terms = {b};
1142 : :
1143 : 2 : cvc5_define_funs_rec(d_solver,
1144 : : funs.size(),
1145 : 1 : funs.data(),
1146 : : nvars.data(),
1147 : : vars.data(),
1148 : 1 : terms.data(),
1149 : : true);
1150 : :
1151 : : // (assert (not (g true)))
1152 : 1 : std::vector<Cvc5Term> args = {g, btrue};
1153 : 1 : Cvc5Term t = cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1154 : 1 : args = {t};
1155 : 1 : cvc5_assert_formula(
1156 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()));
1157 : 1 : Cvc5Result res = cvc5_check_sat(d_solver);
1158 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
1159 : 1 : cvc5_pop(d_solver, 1);
1160 : : // (assert (not (g true)))
1161 : 1 : cvc5_assert_formula(
1162 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()));
1163 : 1 : res = cvc5_check_sat(d_solver);
1164 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
1165 [ + - ][ + - ]: 1 : }
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
1166 : :
1167 : 4 : TEST_F(TestCApiBlackSolver, get_assertions)
1168 : : {
1169 : 1 : Cvc5Term a = cvc5_mk_const(d_tm, d_bool, "a");
1170 : 1 : Cvc5Term b = cvc5_mk_const(d_tm, d_bool, "b");
1171 : 1 : cvc5_assert_formula(d_solver, a);
1172 : 1 : cvc5_assert_formula(d_solver, b);
1173 : : size_t size;
1174 : 1 : auto res = cvc5_get_assertions(d_solver, &size);
1175 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 2);
1176 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(a, res[0]));
1177 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(b, res[1]));
1178 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_assertions(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1179 : : "unexpected NULL argument");
1180 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_assertions(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1181 : : "unexpected NULL argument");
1182 : : }
1183 : :
1184 : 4 : TEST_F(TestCApiBlackSolver, get_info)
1185 : : {
1186 [ - + ][ + - ]: 1 : ASSERT_EQ(cvc5_get_info(d_solver, "name"), std::string("\"cvc5\""));
1187 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_info(d_solver, "asdf"), "unrecognized flag");
[ - + ][ + - ]
[ + - ][ + - ]
1188 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_info(nullptr, "name"), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
1189 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_info(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1190 : : "unexpected NULL argument");
1191 : : }
1192 : :
1193 : 4 : TEST_F(TestCApiBlackSolver, get_option)
1194 : : {
1195 [ - + ][ + - ]: 1 : ASSERT_EQ(cvc5_get_option(d_solver, "incremental"), std::string("true"));
1196 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option(d_solver, "asdf"), "Unrecognized option");
[ - + ][ + - ]
[ + - ][ + - ]
1197 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option(nullptr, "incremental"),
[ - + ][ + - ]
[ + - ][ + - ]
1198 : : "unexpected NULL argument");
1199 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1200 : : "unexpected NULL argument");
1201 : : }
1202 : :
1203 : 4 : TEST_F(TestCApiBlackSolver, get_option_names)
1204 : : {
1205 : : size_t size;
1206 : 1 : auto names = cvc5_get_option_names(d_solver, &size);
1207 [ - + ][ + - ]: 1 : ASSERT_TRUE(size > 100);
1208 : 1 : bool found_verbose = false;
1209 : 1 : bool found_foobar = false;
1210 [ + + ]: 537 : for (size_t i = 0; i < size; ++i)
1211 : : {
1212 [ + + ]: 536 : if (names[i] == std::string("verbose"))
1213 : : {
1214 : 1 : found_verbose = true;
1215 : : }
1216 [ - + ]: 535 : else if (std::string(names[i]) == "foobar")
1217 : : {
1218 : 0 : found_foobar = true;
1219 : : }
1220 : : }
1221 [ - + ][ + - ]: 1 : ASSERT_TRUE(found_verbose);
1222 [ - + ][ + - ]: 1 : ASSERT_FALSE(found_foobar);
1223 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option_names(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1224 : : "unexpected NULL argument");
1225 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option_names(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1226 : : "unexpected NULL argument");
1227 : : }
1228 : :
1229 : 4 : TEST_F(TestCApiBlackSolver, get_option_info)
1230 : : {
1231 : : Cvc5OptionInfo info;
1232 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option_info(nullptr, "verbose", &info),
[ - + ][ + - ]
[ + - ][ + - ]
1233 : : "unexpected NULL argument");
1234 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option_info(d_solver, nullptr, &info),
[ - + ][ + - ]
[ + - ][ + - ]
1235 : : "unexpected NULL argument");
1236 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option_info(d_solver, "verbose", nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1237 : : "unexpected NULL argument");
1238 : : // The info struct is zeroed even if the call fails (issue #12991).
1239 : 1 : std::memset(&info, 0xAB, sizeof(info));
1240 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_option_info(d_solver, "asdf-invalid", &info),
[ - + ][ + - ]
[ + - ][ + - ]
1241 : : "Unrecognized option");
1242 : : Cvc5OptionInfo zero;
1243 : 1 : std::memset(&zero, 0, sizeof(zero));
1244 [ - + ][ + - ]: 1 : ASSERT_EQ(std::memcmp(&info, &zero, sizeof(info)), 0);
1245 : :
1246 : 1 : cvc5_set_option(d_solver, "verbosity", "2");
1247 : :
1248 : 1 : cvc5_get_option_info(d_solver, "verbose", &info);
1249 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("verbose"));
1250 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 0);
1251 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_COMMON);
1252 [ - + ][ + - ]: 1 : ASSERT_FALSE(info.is_set_by_user);
1253 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_VOID);
1254 [ - + ]: 1 : ASSERT_EQ(cvc5_option_info_to_string(&info),
1255 [ + - ]: 1 : std::string("OptionInfo{ verbose | void }"));
1256 : :
1257 : : // bool kind
1258 : 1 : cvc5_get_option_info(d_solver, "print-success", &info);
1259 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("print-success"));
1260 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 0);
1261 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_BOOL);
1262 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_COMMON);
1263 [ - + ][ + - ]: 1 : ASSERT_FALSE(info.is_set_by_user);
1264 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_bool.dflt, false);
1265 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_bool.cur, false);
1266 [ - + ]: 1 : ASSERT_EQ(cvc5_option_info_to_string(&info),
1267 : : std::string(
1268 [ + - ]: 1 : "OptionInfo{ print-success | bool | false | default false }"));
1269 : :
1270 : : // int64 kind
1271 : 1 : cvc5_get_option_info(d_solver, "verbosity", &info);
1272 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("verbosity"));
1273 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 0);
1274 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_COMMON);
1275 [ - + ][ + - ]: 1 : ASSERT_TRUE(info.is_set_by_user);
1276 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_INT64);
1277 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_int.dflt, 0);
1278 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_int.cur, 2);
1279 [ + - ][ + - ]: 1 : ASSERT_FALSE(info.info_int.has_min || info.info_int.has_max);
[ - + ][ + - ]
1280 [ - + ]: 1 : ASSERT_EQ(
1281 : : cvc5_option_info_to_string(&info),
1282 : : std::string(
1283 [ + - ]: 1 : "OptionInfo{ verbosity | set by user | int64_t | 2 | default 0 }"));
1284 : :
1285 : : // uint64 kind
1286 : 1 : cvc5_get_option_info(d_solver, "rlimit", &info);
1287 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("rlimit"));
1288 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 0);
1289 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_COMMON);
1290 [ - + ][ + - ]: 1 : ASSERT_FALSE(info.is_set_by_user);
1291 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_UINT64);
1292 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_uint.dflt, 0);
1293 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_uint.cur, 0);
1294 [ + - ][ + - ]: 1 : ASSERT_FALSE(info.info_uint.has_min || info.info_uint.has_max);
[ - + ][ + - ]
1295 [ - + ]: 1 : ASSERT_EQ(cvc5_option_info_to_string(&info),
1296 [ + - ]: 1 : std::string("OptionInfo{ rlimit | uint64_t | 0 | default 0 }"));
1297 : :
1298 : : // double kind
1299 : 1 : cvc5_get_option_info(d_solver, "random-freq", &info);
1300 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("random-freq"));
1301 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 1);
1302 [ - + ][ + - ]: 2 : ASSERT_EQ(info.aliases[0], std::string("random-frequency"));
1303 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_EXPERT);
1304 [ - + ][ + - ]: 1 : ASSERT_FALSE(info.is_set_by_user);
1305 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_DOUBLE);
1306 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_double.dflt, 0.0);
1307 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_double.cur, 0.0);
1308 [ + - ][ + - ]: 1 : ASSERT_TRUE(info.info_double.has_min && info.info_double.has_max);
[ - + ][ + - ]
1309 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_double.min, 0.0);
1310 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_double.min, 0.0);
1311 [ - + ]: 1 : ASSERT_EQ(cvc5_option_info_to_string(&info),
1312 : : std::string("OptionInfo{ random-freq, random-frequency | double | "
1313 [ + - ]: 1 : "0 | default 0 | 0 <= x <= 1 }"));
1314 : :
1315 : : // string kind
1316 : 1 : cvc5_get_option_info(d_solver, "force-logic", &info);
1317 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("force-logic"));
1318 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 0);
1319 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_COMMON);
1320 [ - + ][ + - ]: 1 : ASSERT_FALSE(info.is_set_by_user);
1321 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_STR);
1322 [ - + ][ + - ]: 2 : ASSERT_EQ(info.info_str.dflt, std::string(""));
1323 [ - + ][ + - ]: 2 : ASSERT_EQ(info.info_str.cur, std::string(""));
1324 [ - + ]: 1 : ASSERT_EQ(
1325 : : cvc5_option_info_to_string(&info),
1326 [ + - ]: 1 : std::string("OptionInfo{ force-logic | string | \"\" | default \"\" }"));
1327 : :
1328 : : // mode option
1329 : 1 : cvc5_get_option_info(d_solver, "simplification", &info);
1330 [ - + ][ + - ]: 2 : ASSERT_EQ(info.name, std::string("simplification"));
1331 [ - + ][ + - ]: 1 : ASSERT_EQ(info.num_aliases, 1);
1332 [ - + ][ + - ]: 2 : ASSERT_EQ(info.aliases[0], std::string("simplification-mode"));
1333 [ - + ][ + - ]: 1 : ASSERT_EQ(info.category, CVC5_OPTION_CATEGORY_REGULAR);
1334 [ - + ][ + - ]: 1 : ASSERT_FALSE(info.is_set_by_user);
1335 [ - + ][ + - ]: 1 : ASSERT_EQ(info.kind, CVC5_OPTION_INFO_MODES);
1336 [ - + ][ + - ]: 2 : ASSERT_EQ(info.info_mode.dflt, std::string("batch"));
1337 [ - + ][ + - ]: 2 : ASSERT_EQ(info.info_mode.cur, std::string("batch"));
1338 [ - + ][ + - ]: 1 : ASSERT_EQ(info.info_mode.num_modes, 2);
1339 : 3 : ASSERT_TRUE((info.info_mode.modes[0] == std::string("batch"))
1340 [ + - ]: 1 : || (info.info_mode.modes[1] == std::string("batch")));
1341 : 5 : ASSERT_TRUE((info.info_mode.modes[0] == std::string("none"))
1342 [ + - ]: 1 : || (info.info_mode.modes[1] == std::string("none")));
1343 [ - + ]: 1 : ASSERT_EQ(cvc5_option_info_to_string(&info),
1344 : : std::string("OptionInfo{ simplification, simplification-mode | "
1345 [ + - ]: 1 : "mode | batch | default batch | modes: batch, none }"));
1346 : : }
1347 : :
1348 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_assumptions1)
1349 : : {
1350 : 1 : cvc5_set_option(d_solver, "incremental", "false");
1351 : 1 : std::vector<Cvc5Term> assumptions = {cvc5_mk_false(d_tm)};
1352 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
1353 : : size_t size;
1354 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_assumptions(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1355 : : "unexpected NULL argument");
1356 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_assumptions(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1357 : : "unexpected NULL argument");
1358 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_assumptions(d_solver, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1359 : : "cannot get unsat assumptions");
1360 [ + - ]: 1 : }
1361 : :
1362 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_assumptions2)
1363 : : {
1364 : 1 : cvc5_set_option(d_solver, "incremental", "false");
1365 : 1 : cvc5_set_option(d_solver, "produce-unsat-assumptions", "false");
1366 : 1 : std::vector<Cvc5Term> assumptions = {cvc5_mk_false(d_tm)};
1367 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
1368 : : size_t size;
1369 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_assumptions(d_solver, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1370 : : "cannot get unsat assumptions");
1371 [ + - ]: 1 : }
1372 : :
1373 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_assumptions3)
1374 : : {
1375 : 1 : cvc5_set_option(d_solver, "incremental", "true");
1376 : 1 : cvc5_set_option(d_solver, "produce-unsat-assumptions", "true");
1377 : 1 : std::vector<Cvc5Term> assumptions = {cvc5_mk_false(d_tm)};
1378 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
1379 : : size_t size;
1380 : 1 : const Cvc5Term* res = cvc5_get_unsat_assumptions(d_solver, &size);
1381 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 1);
1382 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(res[0], cvc5_mk_false(d_tm)));
1383 : 1 : assumptions = {cvc5_mk_true(d_tm)};
1384 : 1 : cvc5_check_sat_assuming(d_solver, assumptions.size(), assumptions.data());
1385 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_assumptions(d_solver, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1386 : : "cannot get unsat assumptions");
1387 [ + - ]: 1 : }
1388 : :
1389 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_core0)
1390 : : {
1391 : 1 : cvc5_set_option(d_solver, "incremental", "true");
1392 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_false(d_tm));
1393 : 1 : cvc5_check_sat(d_solver);
1394 : : size_t size;
1395 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1396 : : "unexpected NULL argument");
1397 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1398 : : "unexpected NULL argument");
1399 : : }
1400 : :
1401 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_core1)
1402 : : {
1403 : 1 : cvc5_set_option(d_solver, "incremental", "false");
1404 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_false(d_tm));
1405 : 1 : cvc5_check_sat(d_solver);
1406 : : size_t size;
1407 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core(d_solver, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1408 : : "cannot get unsat core");
1409 : : }
1410 : :
1411 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_core2)
1412 : : {
1413 : 1 : cvc5_set_option(d_solver, "incremental", "false");
1414 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "false");
1415 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_false(d_tm));
1416 : 1 : cvc5_check_sat(d_solver);
1417 : : size_t size;
1418 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core(d_solver, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1419 : : "cannot get unsat core");
1420 : : }
1421 : :
1422 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_core_and_proof)
1423 : : {
1424 : 1 : cvc5_set_option(d_solver, "incremental", "true");
1425 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1426 : 1 : cvc5_set_option(d_solver, "produce-proofs", "true");
1427 : :
1428 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
1429 : : Cvc5Sort u_to_int =
1430 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
1431 : 1 : domain = {d_int};
1432 : : Cvc5Sort int_pred =
1433 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
1434 : :
1435 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
1436 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
1437 : 1 : Cvc5Term f = cvc5_mk_const(d_tm, u_to_int, "f");
1438 : 1 : Cvc5Term p = cvc5_mk_const(d_tm, int_pred, "p");
1439 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
1440 : 1 : Cvc5Term one = cvc5_mk_integer_int64(d_tm, 1);
1441 : 1 : std::vector<Cvc5Term> args = {f, x};
1442 : : Cvc5Term f_x =
1443 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1444 : 1 : args = {f, y};
1445 : : Cvc5Term f_y =
1446 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1447 : 1 : args = {f_x, f_y};
1448 : 1 : Cvc5Term sum = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
1449 : 1 : args = {p, zero};
1450 : : Cvc5Term p_0 =
1451 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1452 : 1 : args = {p, f_y};
1453 : : Cvc5Term p_f_y =
1454 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1455 : :
1456 : 1 : args = {zero, f_x};
1457 : 1 : cvc5_assert_formula(
1458 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1459 : 1 : args = {zero, f_y};
1460 : 1 : cvc5_assert_formula(
1461 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1462 : 1 : args = {sum, one};
1463 : 1 : cvc5_assert_formula(
1464 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1465 : 1 : cvc5_assert_formula(d_solver, p_0);
1466 : 1 : args = {p_f_y};
1467 : 1 : cvc5_assert_formula(
1468 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()));
1469 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
1470 : :
1471 : : size_t uc_size, proof_size;
1472 : 1 : const Cvc5Term* uc = cvc5_get_unsat_core(d_solver, &uc_size);
1473 [ - + ][ + - ]: 1 : ASSERT_TRUE(uc_size > 0);
1474 : :
1475 : 1 : (void)cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_FULL, &proof_size);
1476 : 1 : (void)cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_SAT, &proof_size);
1477 : :
1478 : 1 : cvc5_reset_assertions(d_solver);
1479 [ + + ]: 4 : for (size_t i = 0; i < uc_size; ++i)
1480 : : {
1481 : 3 : cvc5_assert_formula(d_solver, uc[i]);
1482 : : }
1483 : 1 : Cvc5Result res = cvc5_check_sat(d_solver);
1484 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(res));
1485 : 1 : (void)cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_FULL, &proof_size);
1486 [ + - ][ + - ]: 1 : }
1487 : :
1488 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_core_lemmas1)
1489 : : {
1490 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1491 : 1 : cvc5_set_option(d_solver, "unsat-cores-mode", "sat-proof");
1492 : :
1493 : : size_t size;
1494 : : // cannot ask before a check sat
1495 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core_lemmas(d_solver, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1496 : : "cannot get unsat core");
1497 : :
1498 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_false(d_tm));
1499 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
1500 : 1 : (void)cvc5_get_unsat_core_lemmas(d_solver, &size);
1501 : :
1502 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core_lemmas(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1503 : : "unexpected NULL argument");
1504 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_unsat_core_lemmas(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1505 : : "unexpected NULL argument");
1506 : : }
1507 : :
1508 : 4 : TEST_F(TestCApiBlackSolver, get_unsat_core_lemmas2)
1509 : : {
1510 : 1 : cvc5_set_option(d_solver, "incremental", "true");
1511 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1512 : 1 : cvc5_set_option(d_solver, "produce-proofs", "true");
1513 : :
1514 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
1515 : : Cvc5Sort u_to_int =
1516 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
1517 : 1 : domain = {d_int};
1518 : : Cvc5Sort int_pred =
1519 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
1520 : :
1521 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
1522 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
1523 : 1 : Cvc5Term f = cvc5_mk_const(d_tm, u_to_int, "f");
1524 : 1 : Cvc5Term p = cvc5_mk_const(d_tm, int_pred, "p");
1525 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
1526 : 1 : Cvc5Term one = cvc5_mk_integer_int64(d_tm, 1);
1527 : 1 : std::vector<Cvc5Term> args = {f, x};
1528 : : Cvc5Term f_x =
1529 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1530 : 1 : args = {f, y};
1531 : : Cvc5Term f_y =
1532 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1533 : 1 : args = {f_x, f_y};
1534 : 1 : Cvc5Term sum = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
1535 : 1 : args = {p, zero};
1536 : : Cvc5Term p_0 =
1537 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1538 : 1 : args = {p, f_y};
1539 : : Cvc5Term p_f_y =
1540 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1541 : :
1542 : 1 : args = {zero, f_x};
1543 : 1 : cvc5_assert_formula(
1544 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1545 : 1 : args = {zero, f_y};
1546 : 1 : cvc5_assert_formula(
1547 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1548 : 1 : args = {sum, one};
1549 : 1 : cvc5_assert_formula(
1550 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1551 : 1 : cvc5_assert_formula(d_solver, p_0);
1552 : 1 : args = {p_f_y};
1553 : 1 : cvc5_assert_formula(
1554 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()));
1555 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
1556 : :
1557 : : size_t size;
1558 : 1 : (void)cvc5_get_unsat_core_lemmas(d_solver, &size);
1559 [ + - ][ + - ]: 1 : }
1560 : :
1561 : 4 : TEST_F(TestCApiBlackSolver, get_difficulty)
1562 : : {
1563 : 1 : cvc5_set_option(d_solver, "produce-difficulty", "true");
1564 : : size_t size;
1565 : : Cvc5Term *inputs, *values;
1566 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_difficulty(nullptr, &size, &inputs, &values),
[ - + ][ + - ]
[ + - ][ + - ]
1567 : : "unexpected NULL argument");
1568 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_difficulty(d_solver, nullptr, &inputs, &values),
[ - + ][ + - ]
[ + - ][ + - ]
1569 : : "unexpected NULL argument");
1570 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_difficulty(d_solver, &size, nullptr, &values),
[ - + ][ + - ]
[ + - ][ + - ]
1571 : : "unexpected NULL argument");
1572 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_difficulty(d_solver, &size, &inputs, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1573 : : "unexpected NULL argument");
1574 : : // cannot ask before a check sat
1575 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_difficulty(d_solver, &size, &inputs, &values),
[ - + ][ + - ]
[ + - ][ + - ]
1576 : : "cannot get difficulty");
1577 : 1 : cvc5_check_sat(d_solver);
1578 : 1 : cvc5_get_difficulty(d_solver, &size, &inputs, &values);
1579 : : }
1580 : :
1581 : 4 : TEST_F(TestCApiBlackSolver, get_difficulty2)
1582 : : {
1583 : 1 : cvc5_check_sat(d_solver);
1584 : : size_t size;
1585 : : Cvc5Term *inputs, *values;
1586 : : // option is not set
1587 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_difficulty(d_solver, &size, &inputs, &values),
[ - + ][ + - ]
[ + - ][ + - ]
1588 : : "Cannot get difficulty");
1589 : : }
1590 : :
1591 : 4 : TEST_F(TestCApiBlackSolver, get_difficulty3)
1592 : : {
1593 : 1 : cvc5_set_option(d_solver, "produce-difficulty", "true");
1594 : : size_t size;
1595 : : Cvc5Term *inputs, *values;
1596 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
1597 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
1598 : 1 : Cvc5Term ten = cvc5_mk_integer_int64(d_tm, 10);
1599 : 1 : std::vector<Cvc5Term> args = {x, ten};
1600 : 1 : Cvc5Term f0 = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
1601 : 1 : args = {zero, x};
1602 : 1 : Cvc5Term f1 = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
1603 : 1 : cvc5_assert_formula(d_solver, f0);
1604 : 1 : cvc5_assert_formula(d_solver, f1);
1605 : 1 : cvc5_check_sat(d_solver);
1606 : 1 : cvc5_get_difficulty(d_solver, &size, &inputs, &values);
1607 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 2);
1608 : : // difficulty should map assertions to integer values
1609 [ + + ]: 3 : for (size_t i = 0; i < size; ++i)
1610 : : {
1611 [ + + ][ + - ]: 2 : ASSERT_TRUE(cvc5_term_is_equal(inputs[i], f0)
[ - + ]
1612 [ + - ]: 2 : || cvc5_term_is_equal(inputs[i], f1));
1613 [ - + ][ + - ]: 2 : ASSERT_EQ(cvc5_term_get_kind(values[i]), CVC5_KIND_CONST_INTEGER);
1614 : : }
1615 [ + - ]: 1 : }
1616 : :
1617 : 4 : TEST_F(TestCApiBlackSolver, get_timeout_core)
1618 : : {
1619 : 1 : cvc5_set_option(d_solver, "timeout-core-timeout", "100");
1620 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1621 : :
1622 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
1623 : 1 : Cvc5Term tt = cvc5_mk_true(d_tm);
1624 : 1 : std::vector<Cvc5Term> args = {x, x};
1625 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_MULT, args.size(), args.data()),
1626 : 1 : cvc5_mk_integer(d_tm, "501240912901901249014210220059591")};
1627 : 1 : Cvc5Term hard = cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
1628 : 1 : cvc5_assert_formula(d_solver, tt);
1629 : 1 : cvc5_assert_formula(d_solver, hard);
1630 : :
1631 : : Cvc5Result result;
1632 : : size_t size;
1633 : 1 : const Cvc5Term* core = cvc5_get_timeout_core(d_solver, &result, &size);
1634 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unknown(result));
1635 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 1);
1636 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(core[0], hard));
1637 : :
1638 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_timeout_core(nullptr, &result, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1639 : : "unexpected NULL argument");
1640 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_timeout_core(d_solver, nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1641 : : "unexpected NULL argument");
1642 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_timeout_core(d_solver, &result, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
1643 : : "unexpected NULL argument");
1644 [ + - ]: 1 : }
1645 : :
1646 : 4 : TEST_F(TestCApiBlackSolver, get_timeout_core_unsat)
1647 : : {
1648 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1649 : 1 : Cvc5Term ff = cvc5_mk_false(d_tm);
1650 : 1 : Cvc5Term tt = cvc5_mk_true(d_tm);
1651 : 1 : cvc5_assert_formula(d_solver, tt);
1652 : 1 : cvc5_assert_formula(d_solver, ff);
1653 : 1 : cvc5_assert_formula(d_solver, tt);
1654 : :
1655 : : Cvc5Result result;
1656 : : size_t size;
1657 : 1 : const Cvc5Term* core = cvc5_get_timeout_core(d_solver, &result, &size);
1658 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(result));
1659 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 1);
1660 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(core[0], ff));
1661 : : }
1662 : :
1663 : 4 : TEST_F(TestCApiBlackSolver, get_timeout_core_assuming)
1664 : : {
1665 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1666 : 1 : Cvc5Term ff = cvc5_mk_false(d_tm);
1667 : 1 : Cvc5Term tt = cvc5_mk_true(d_tm);
1668 : 1 : cvc5_assert_formula(d_solver, tt);
1669 : :
1670 : 1 : std::vector<Cvc5Term> assumptions = {ff, tt};
1671 : : Cvc5Result result;
1672 : : size_t size;
1673 : 1 : const Cvc5Term* core = cvc5_get_timeout_core_assuming(
1674 : 1 : d_solver, assumptions.size(), assumptions.data(), &result, &size);
1675 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(result));
1676 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 1);
1677 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(core[0], ff));
1678 [ + - ]: 1 : }
1679 : :
1680 : 4 : TEST_F(TestCApiBlackSolver, get_timeout_core_assuming_empty)
1681 : : {
1682 : 1 : cvc5_set_option(d_solver, "produce-unsat-cores", "true");
1683 : 1 : std::vector<Cvc5Term> assumptions = {};
1684 : : Cvc5Result result;
1685 : : size_t size;
1686 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1687 : : cvc5_get_timeout_core_assuming(
1688 : : d_solver, assumptions.size(), assumptions.data(), &result, &size),
1689 : : "unexpected NULL argument");
1690 [ + - ]: 1 : }
1691 : :
1692 : 4 : TEST_F(TestCApiBlackSolver, get_proof_and_proof_to_string)
1693 : : {
1694 : 1 : cvc5_set_option(d_solver, "produce-proofs", "true");
1695 : :
1696 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
1697 : : Cvc5Sort u_to_int =
1698 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
1699 : 1 : domain = {d_int};
1700 : : Cvc5Sort int_pred =
1701 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
1702 : :
1703 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
1704 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
1705 : 1 : Cvc5Term f = cvc5_mk_const(d_tm, u_to_int, "f");
1706 : 1 : Cvc5Term p = cvc5_mk_const(d_tm, int_pred, "p");
1707 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
1708 : 1 : Cvc5Term one = cvc5_mk_integer_int64(d_tm, 1);
1709 : 1 : std::vector<Cvc5Term> args = {f, x};
1710 : : Cvc5Term f_x =
1711 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1712 : 1 : args = {f, y};
1713 : : Cvc5Term f_y =
1714 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1715 : 1 : args = {f_x, f_y};
1716 : 1 : Cvc5Term sum = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
1717 : 1 : args = {p, zero};
1718 : : Cvc5Term p_0 =
1719 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1720 : 1 : args = {p, f_y};
1721 : : Cvc5Term p_f_y =
1722 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1723 : :
1724 : 1 : args = {zero, f_x};
1725 : 1 : cvc5_assert_formula(
1726 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1727 : 1 : args = {zero, f_y};
1728 : 1 : cvc5_assert_formula(
1729 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1730 : 1 : args = {sum, one};
1731 : 1 : cvc5_assert_formula(
1732 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
1733 : 1 : cvc5_assert_formula(d_solver, p_0);
1734 : 1 : args = {p_f_y};
1735 : 1 : cvc5_assert_formula(
1736 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()));
1737 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
1738 : :
1739 : : size_t size;
1740 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_proof(nullptr, CVC5_PROOF_COMPONENT_FULL, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1741 : : "unexpected NULL");
1742 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1743 : : cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_FULL, nullptr),
1744 : : "unexpected NULL");
1745 : :
1746 : : const Cvc5Proof* proofs =
1747 : 1 : cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_FULL, &size);
1748 [ - + ][ + - ]: 1 : ASSERT_TRUE(size > 0);
1749 : :
1750 : : std::string proof_str = cvc5_proof_to_string(
1751 : 1 : d_solver, proofs[0], CVC5_PROOF_FORMAT_DEFAULT, 0, nullptr, nullptr);
1752 [ - + ][ + - ]: 1 : ASSERT_FALSE(proof_str.empty());
1753 : : proof_str = cvc5_proof_to_string(
1754 : 1 : d_solver, proofs[0], CVC5_PROOF_FORMAT_ALETHE, 0, nullptr, nullptr);
1755 [ - + ][ + - ]: 1 : ASSERT_FALSE(proof_str.empty());
1756 : 1 : proofs = cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_SAT, &size);
1757 : : proof_str = cvc5_proof_to_string(
1758 : 1 : d_solver, proofs[0], CVC5_PROOF_FORMAT_NONE, 0, nullptr, nullptr);
1759 [ - + ][ + - ]: 1 : ASSERT_FALSE(proof_str.empty());
1760 [ + - ][ + - ]: 1 : }
1761 : :
1762 : 4 : TEST_F(TestCApiBlackSolver, proof_to_string_assertion_names)
1763 : : {
1764 : 1 : cvc5_set_option(d_solver, "produce-proofs", "true");
1765 : :
1766 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
1767 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
1768 : :
1769 : 1 : std::vector<Cvc5Term> args = {x, y};
1770 : : Cvc5Term x_eq_y =
1771 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
1772 : 1 : args = {x_eq_y};
1773 : : Cvc5Term not_x_eq_y =
1774 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
1775 : :
1776 : 1 : cvc5_assert_formula(d_solver, x_eq_y);
1777 : 1 : cvc5_assert_formula(d_solver, not_x_eq_y);
1778 : :
1779 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
1780 : :
1781 : : size_t size;
1782 : : const Cvc5Proof* proofs =
1783 : 1 : cvc5_get_proof(d_solver, CVC5_PROOF_COMPONENT_FULL, &size);
1784 [ - + ][ + - ]: 1 : ASSERT_TRUE(size > 0);
1785 : 1 : const Cvc5Term assertions[2] = {x_eq_y, not_x_eq_y};
1786 : 1 : const char* names[2] = {"as1", "as2"};
1787 : : std::string proof_str = cvc5_proof_to_string(
1788 : 1 : d_solver, proofs[0], CVC5_PROOF_FORMAT_ALETHE, 2, assertions, names);
1789 [ - + ][ + - ]: 1 : ASSERT_FALSE(proof_str.empty());
1790 [ - + ][ + - ]: 1 : ASSERT_LT(proof_str.find("as1"), std::string::npos);
1791 [ - + ][ + - ]: 1 : ASSERT_LT(proof_str.find("as2"), std::string::npos);
1792 : :
1793 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_proof_to_string(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
1794 : : proofs[0],
1795 : : CVC5_PROOF_FORMAT_ALETHE,
1796 : : 2,
1797 : : assertions,
1798 : : nullptr),
1799 : : "unexpected NULL argument");
1800 : 1 : const Cvc5Term null_assertions[2] = {x_eq_y, nullptr};
1801 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_proof_to_string(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
1802 : : proofs[0],
1803 : : CVC5_PROOF_FORMAT_ALETHE,
1804 : : 2,
1805 : : null_assertions,
1806 : : names),
1807 : : "invalid term at index 1");
1808 : 1 : const char* null_names[2] = {"as1", nullptr};
1809 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_proof_to_string(d_solver,
[ - + ][ + - ]
[ + - ][ + - ]
1810 : : proofs[0],
1811 : : CVC5_PROOF_FORMAT_ALETHE,
1812 : : 2,
1813 : : assertions,
1814 : : null_names),
1815 : : "unexpected NULL argument at index 1");
1816 [ + - ]: 1 : }
1817 : :
1818 : 4 : TEST_F(TestCApiBlackSolver, get_learned_literals)
1819 : : {
1820 : 1 : cvc5_set_option(d_solver, "produce-learned-literals", "true");
1821 : :
1822 : : size_t size;
1823 : : // cannot ask before a check sat
1824 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1825 : : cvc5_get_learned_literals(d_solver, CVC5_LEARNED_LIT_TYPE_INPUT, &size),
1826 : : "cannot get learned literals");
1827 : :
1828 : 1 : cvc5_check_sat(d_solver);
1829 : 1 : (void)cvc5_get_learned_literals(d_solver, CVC5_LEARNED_LIT_TYPE_INPUT, &size);
1830 : 1 : (void)cvc5_get_learned_literals(
1831 : : d_solver, CVC5_LEARNED_LIT_TYPE_PREPROCESS, &size);
1832 : :
1833 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1834 : : cvc5_get_learned_literals(nullptr, CVC5_LEARNED_LIT_TYPE_INPUT, &size),
1835 : : "unexpected NULL argument");
1836 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1837 : : cvc5_get_learned_literals(d_solver, CVC5_LEARNED_LIT_TYPE_INPUT, nullptr),
1838 : : "unexpected NULL argument");
1839 : : }
1840 : :
1841 : 4 : TEST_F(TestCApiBlackSolver, get_learned_literals2)
1842 : : {
1843 : 1 : cvc5_set_option(d_solver, "produce-learned-literals", "true");
1844 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
1845 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
1846 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
1847 : 1 : Cvc5Term ten = cvc5_mk_integer_int64(d_tm, 10);
1848 : 1 : std::vector<Cvc5Term> args = {x, ten};
1849 : 1 : Cvc5Term f0 = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
1850 : 1 : args = {zero, x};
1851 : 1 : Cvc5Term args1 = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
1852 : 1 : args = {y, zero};
1853 : 1 : Cvc5Term args2 = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
1854 : 1 : args = {args1, args2};
1855 : 1 : Cvc5Term f1 = cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data());
1856 : 1 : cvc5_assert_formula(d_solver, f0);
1857 : 1 : cvc5_assert_formula(d_solver, f1);
1858 : 1 : cvc5_check_sat(d_solver);
1859 : : size_t size;
1860 : 1 : (void)cvc5_get_learned_literals(d_solver, CVC5_LEARNED_LIT_TYPE_INPUT, &size);
1861 : 1 : }
1862 : :
1863 : 4 : TEST_F(TestCApiBlackSolver, get_value1)
1864 : : {
1865 : 1 : cvc5_set_option(d_solver, "produce-models", "false");
1866 : 1 : Cvc5Term t = cvc5_mk_true(d_tm);
1867 : 1 : cvc5_assert_formula(d_solver, t);
1868 : 1 : cvc5_check_sat(d_solver);
1869 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value(d_solver, t), "cannot get value");
[ - + ][ + - ]
[ + - ][ + - ]
1870 : : }
1871 : :
1872 : 4 : TEST_F(TestCApiBlackSolver, get_value2)
1873 : : {
1874 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
1875 : 1 : Cvc5Term t = cvc5_mk_false(d_tm);
1876 : 1 : cvc5_assert_formula(d_solver, t);
1877 : 1 : cvc5_check_sat(d_solver);
1878 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value(d_solver, t), "cannot get value");
[ - + ][ + - ]
[ + - ][ + - ]
1879 : : }
1880 : :
1881 : 4 : TEST_F(TestCApiBlackSolver, get_value3)
1882 : : {
1883 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
1884 : :
1885 : 1 : std::vector<Cvc5Sort> domain = {d_uninterpreted};
1886 : : Cvc5Sort u_to_int =
1887 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_int);
1888 : 1 : domain = {d_int};
1889 : : Cvc5Sort int_pred =
1890 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
1891 : :
1892 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
1893 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
1894 : 1 : Cvc5Term z = cvc5_mk_const(d_tm, d_uninterpreted, "z");
1895 : 1 : Cvc5Term f = cvc5_mk_const(d_tm, u_to_int, "f");
1896 : 1 : Cvc5Term p = cvc5_mk_const(d_tm, int_pred, "p");
1897 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
1898 : 1 : Cvc5Term one = cvc5_mk_integer_int64(d_tm, 1);
1899 : 1 : std::vector<Cvc5Term> args = {f, x};
1900 : : Cvc5Term f_x =
1901 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1902 : 1 : args = {f, y};
1903 : : Cvc5Term f_y =
1904 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1905 : 1 : args = {f_x, f_y};
1906 : 1 : Cvc5Term sum = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
1907 : 1 : args = {p, zero};
1908 : : Cvc5Term p_0 =
1909 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1910 : 1 : args = {p, f_y};
1911 : : Cvc5Term p_f_y =
1912 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
1913 : :
1914 : 1 : args = {zero, f_x};
1915 : 1 : cvc5_assert_formula(
1916 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data()));
1917 : 1 : args = {zero, f_y};
1918 : 1 : cvc5_assert_formula(
1919 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data()));
1920 : 1 : args = {sum, one};
1921 : 1 : cvc5_assert_formula(
1922 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data()));
1923 : 1 : args = {p_0};
1924 : 1 : cvc5_assert_formula(
1925 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()));
1926 : 1 : cvc5_assert_formula(d_solver, p_f_y);
1927 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
1928 : :
1929 : 1 : (void)cvc5_get_value(d_solver, x);
1930 : 1 : (void)cvc5_get_value(d_solver, y);
1931 : 1 : (void)cvc5_get_value(d_solver, z);
1932 : 1 : (void)cvc5_get_value(d_solver, sum);
1933 : 1 : (void)cvc5_get_value(d_solver, p_f_y);
1934 : :
1935 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value(nullptr, x), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
1936 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
1937 : :
1938 : 1 : std::vector<Cvc5Term> a = {cvc5_get_value(d_solver, x),
1939 : 2 : cvc5_get_value(d_solver, y),
1940 : 1 : cvc5_get_value(d_solver, z)};
1941 : : size_t size;
1942 : 1 : std::vector<Cvc5Term> terms = {x, y, z};
1943 : : const Cvc5Term* b =
1944 : 1 : cvc5_get_values(d_solver, terms.size(), terms.data(), &size);
1945 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 3);
1946 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(a[0], b[0]));
1947 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(a[1], b[1]));
1948 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_values(nullptr, terms.size(), terms.data(), &size),
[ - + ][ + - ]
[ + - ][ + - ]
1949 : : "unexpected NULL argument");
1950 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_values(d_solver, terms.size(), nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
1951 : : "unexpected NULL argument");
1952 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1953 : : cvc5_get_values(d_solver, terms.size(), terms.data(), nullptr),
1954 : : "unexpected NULL argument");
1955 : 1 : terms = {x, nullptr};
1956 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1957 : : cvc5_get_values(d_solver, terms.size(), terms.data(), &size),
1958 : : "invalid term at index 1");
1959 : :
1960 : 1 : Cvc5* slv = cvc5_new(d_tm);
1961 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value(slv, x), "cannot get value");
[ - + ][ + - ]
[ + - ][ + - ]
1962 : 1 : cvc5_delete(slv);
1963 : :
1964 : 1 : slv = cvc5_new(d_tm);
1965 : 1 : cvc5_set_option(slv, "produce-models", "true");
1966 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value(slv, x), "cannot get value");
[ - + ][ + - ]
[ + - ][ + - ]
1967 : 1 : cvc5_delete(slv);
1968 : :
1969 : 1 : slv = cvc5_new(d_tm);
1970 : 1 : cvc5_set_option(slv, "produce-models", "true");
1971 : 1 : cvc5_check_sat(slv);
1972 : 1 : (void)cvc5_get_value(slv, x);
1973 : 1 : cvc5_delete(slv);
1974 : :
1975 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
1976 : 1 : slv = cvc5_new(tm);
1977 : 1 : cvc5_set_option(slv, "produce-models", "true");
1978 : 1 : cvc5_check_sat(slv);
1979 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
1980 : : cvc5_get_value(slv, x),
1981 : : "term is not associated with the term manager of this solver");
1982 : 1 : cvc5_delete(slv);
1983 : 1 : cvc5_term_manager_release(tm);
1984 : 1 : cvc5_term_manager_delete(tm);
1985 [ + - ][ + - ]: 1 : }
1986 : :
1987 : 4 : TEST_F(TestCApiBlackSolver, get_modelDomain_elements)
1988 : : {
1989 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
1990 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
1991 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
1992 : 1 : Cvc5Term z = cvc5_mk_const(d_tm, d_uninterpreted, "z");
1993 : 1 : std::vector<Cvc5Term> args = {x, y, z};
1994 : 1 : Cvc5Term f = cvc5_mk_term(d_tm, CVC5_KIND_DISTINCT, args.size(), args.data());
1995 : 1 : cvc5_assert_formula(d_solver, f);
1996 : 1 : cvc5_check_sat(d_solver);
1997 : : size_t size;
1998 : 1 : (void)cvc5_get_model_domain_elements(d_solver, d_uninterpreted, &size);
1999 [ - + ][ + - ]: 1 : ASSERT_TRUE(size >= 3);
2000 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2001 : : cvc5_get_model_domain_elements(nullptr, d_uninterpreted, &size),
2002 : : "unexpected NULL argument");
2003 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_model_domain_elements(d_solver, nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
2004 : : "invalid sort");
2005 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2006 : : cvc5_get_model_domain_elements(d_solver, d_uninterpreted, nullptr),
2007 : : "unexpected NULL argument");
2008 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_model_domain_elements(d_solver, d_int, &size),
[ - + ][ + - ]
[ + - ][ + - ]
2009 : : "expected an uninterpreted sort");
2010 : :
2011 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2012 : 1 : Cvc5* slv = cvc5_new(tm);
2013 : 1 : cvc5_set_option(slv, "produce-models", "true");
2014 : 1 : cvc5_check_sat(slv);
2015 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2016 : : cvc5_get_model_domain_elements(slv, d_uninterpreted, &size),
2017 : : "sort is not associated with the term manager of this solver");
2018 : 1 : cvc5_delete(slv);
2019 : 1 : cvc5_term_manager_release(tm);
2020 : 1 : cvc5_term_manager_delete(tm);
2021 [ + - ]: 1 : }
2022 : :
2023 : 4 : TEST_F(TestCApiBlackSolver, getModel_domain_elements2)
2024 : : {
2025 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2026 : 1 : cvc5_set_option(d_solver, "finite-model-find", "true");
2027 : 1 : Cvc5Term x = cvc5_mk_var(d_tm, d_uninterpreted, "x");
2028 : 1 : Cvc5Term y = cvc5_mk_var(d_tm, d_uninterpreted, "y");
2029 : 1 : std::vector<Cvc5Term> args = {x, y};
2030 : 1 : Cvc5Term eq = cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
2031 : : Cvc5Term bvl =
2032 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_VARIABLE_LIST, args.size(), args.data());
2033 : 1 : args = {bvl, eq};
2034 : 1 : Cvc5Term f = cvc5_mk_term(d_tm, CVC5_KIND_FORALL, args.size(), args.data());
2035 : 1 : cvc5_assert_formula(d_solver, f);
2036 : 1 : cvc5_check_sat(d_solver);
2037 : : size_t size;
2038 : 1 : (void)cvc5_get_model_domain_elements(d_solver, d_uninterpreted, &size);
2039 : : // a model for the above must interpret u as size 1
2040 [ - + ][ + - ]: 1 : ASSERT_EQ(size, 1);
2041 [ + - ]: 1 : }
2042 : :
2043 : 4 : TEST_F(TestCApiBlackSolver, is_model_core_symbol)
2044 : : {
2045 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2046 : 1 : cvc5_set_option(d_solver, "model-cores", "simple");
2047 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
2048 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
2049 : 1 : Cvc5Term z = cvc5_mk_const(d_tm, d_uninterpreted, "z");
2050 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
2051 : 1 : std::vector<Cvc5Term> args = {x, y};
2052 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data())};
2053 : 1 : Cvc5Term f = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
2054 : 1 : cvc5_assert_formula(d_solver, f);
2055 : 1 : cvc5_check_sat(d_solver);
2056 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_is_model_core_symbol(d_solver, x));
2057 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_is_model_core_symbol(d_solver, y));
2058 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_is_model_core_symbol(d_solver, z));
2059 : :
2060 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_is_model_core_symbol(nullptr, x),
[ - + ][ + - ]
[ + - ][ + - ]
2061 : : "unexpected NULL argument");
2062 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_is_model_core_symbol(d_solver, nullptr));
2063 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_is_model_core_symbol(d_solver, zero),
[ - + ][ + - ]
[ + - ][ + - ]
2064 : : "expected a free constant");
2065 : :
2066 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2067 : 1 : Cvc5* slv = cvc5_new(tm);
2068 : 1 : cvc5_set_option(slv, "produce-models", "true");
2069 : 1 : cvc5_check_sat(slv);
2070 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2071 : : cvc5_is_model_core_symbol(slv, x),
2072 : : "term is not associated with the term manager of this solver");
2073 : 1 : cvc5_delete(slv);
2074 : 1 : cvc5_term_manager_release(tm);
2075 : 1 : cvc5_term_manager_delete(tm);
2076 [ + - ]: 1 : }
2077 : :
2078 : 4 : TEST_F(TestCApiBlackSolver, get_model)
2079 : : {
2080 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2081 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_uninterpreted, "x");
2082 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_uninterpreted, "y");
2083 : 1 : std::vector<Cvc5Term> args = {x, y};
2084 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data())};
2085 : 1 : Cvc5Term f = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
2086 : 1 : cvc5_assert_formula(d_solver, f);
2087 : 1 : cvc5_check_sat(d_solver);
2088 : :
2089 : 1 : std::vector<Cvc5Sort> sorts = {d_uninterpreted};
2090 : 1 : std::vector<Cvc5Term> terms = {x, y};
2091 : 2 : (void)cvc5_get_model(
2092 : 2 : d_solver, sorts.size(), sorts.data(), terms.size(), terms.data());
2093 : :
2094 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2095 : : cvc5_get_model(
2096 : : nullptr, sorts.size(), sorts.data(), terms.size(), terms.data()),
2097 : : "unexpected NULL argument");
2098 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2099 : : cvc5_get_model(
2100 : : d_solver, sorts.size(), nullptr, terms.size(), terms.data()),
2101 : : "unexpected NULL argument");
2102 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2103 : : cvc5_get_model(
2104 : : d_solver, sorts.size(), sorts.data(), terms.size(), nullptr),
2105 : : "unexpected NULL argument");
2106 : 1 : terms.push_back(nullptr);
2107 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2108 : : cvc5_get_model(
2109 : : d_solver, sorts.size(), sorts.data(), terms.size(), terms.data()),
2110 : : "");
2111 [ + - ][ + - ]: 1 : }
[ + - ]
2112 : :
2113 : 4 : TEST_F(TestCApiBlackSolver, get_model2)
2114 : : {
2115 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2116 : 1 : std::vector<Cvc5Sort> sorts;
2117 : 1 : std::vector<Cvc5Term> terms;
2118 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2119 : : cvc5_get_model(
2120 : : d_solver, sorts.size(), sorts.data(), terms.size(), terms.data()),
2121 : : "unexpected NULL argument");
2122 [ + - ][ + - ]: 1 : }
2123 : :
2124 : 4 : TEST_F(TestCApiBlackSolver, get_model3)
2125 : : {
2126 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2127 : 1 : std::vector<Cvc5Sort> sorts;
2128 : 1 : std::vector<Cvc5Term> terms;
2129 : 1 : cvc5_check_sat(d_solver);
2130 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2131 : : cvc5_get_model(
2132 : : d_solver, sorts.size(), sorts.data(), terms.size(), terms.data()),
2133 : : "unexpected NULL argument");
2134 : 1 : sorts.push_back(d_int);
2135 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2136 : : cvc5_get_model(
2137 : : d_solver, sorts.size(), sorts.data(), terms.size(), terms.data()),
2138 : : "unexpected NULL argument");
2139 [ + - ][ + - ]: 1 : }
2140 : :
2141 : 4 : TEST_F(TestCApiBlackSolver, get_quantifier_elimination)
2142 : : {
2143 : 1 : Cvc5Term x = cvc5_mk_var(d_tm, d_bool, "x");
2144 : 1 : std::vector<Cvc5Term> args = {x};
2145 : : Cvc5Term vlist =
2146 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_VARIABLE_LIST, args.size(), args.data());
2147 : 1 : args = {x, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data())};
2148 : 1 : Cvc5Term b = cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data());
2149 : 1 : args = {vlist, b};
2150 : : Cvc5Term forall =
2151 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_FORALL, args.size(), args.data());
2152 : :
2153 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_quantifier_elimination(nullptr, forall),
[ - + ][ + - ]
[ + - ][ + - ]
2154 : : "unexpected NULL argument");
2155 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_quantifier_elimination(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
2156 : : "invalid term");
2157 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2158 : : cvc5_get_quantifier_elimination(d_solver, cvc5_mk_false(d_tm)),
2159 : : "Expecting a quantified formula");
2160 : 1 : (void)cvc5_get_quantifier_elimination(d_solver, forall);
2161 : :
2162 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2163 : 1 : Cvc5* slv = cvc5_new(tm);
2164 : 1 : cvc5_check_sat(slv);
2165 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2166 : : cvc5_get_quantifier_elimination(slv, forall),
2167 : : "term is not associated with the term manager of this solver");
2168 : 1 : cvc5_delete(slv);
2169 : 1 : cvc5_term_manager_release(tm);
2170 : 1 : cvc5_term_manager_delete(tm);
2171 [ + - ]: 1 : }
2172 : :
2173 : 4 : TEST_F(TestCApiBlackSolver, get_quantifier_elimination_disjunct)
2174 : : {
2175 : 1 : Cvc5Term x = cvc5_mk_var(d_tm, d_bool, "x");
2176 : 1 : std::vector<Cvc5Term> args = {x};
2177 : : Cvc5Term vlist =
2178 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_VARIABLE_LIST, args.size(), args.data());
2179 : 1 : args = {x, cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data())};
2180 : 1 : Cvc5Term b = cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data());
2181 : 1 : args = {vlist, b};
2182 : : Cvc5Term forall =
2183 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_FORALL, args.size(), args.data());
2184 : :
2185 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_quantifier_elimination_disjunct(nullptr, forall),
[ - + ][ + - ]
[ + - ][ + - ]
2186 : : "unexpected NULL argument");
2187 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_quantifier_elimination_disjunct(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
2188 : : "invalid term");
2189 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2190 : : cvc5_get_quantifier_elimination_disjunct(d_solver, cvc5_mk_false(d_tm)),
2191 : : "Expecting a quantified formula");
2192 : 1 : (void)cvc5_get_quantifier_elimination_disjunct(d_solver, forall);
2193 : :
2194 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2195 : 1 : Cvc5* slv = cvc5_new(tm);
2196 : 1 : cvc5_check_sat(slv);
2197 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2198 : : cvc5_get_quantifier_elimination(slv, forall),
2199 : : "term is not associated with the term manager of this solver");
2200 : 1 : cvc5_delete(slv);
2201 : 1 : cvc5_term_manager_release(tm);
2202 : 1 : cvc5_term_manager_delete(tm);
2203 [ + - ]: 1 : }
2204 : :
2205 : 4 : TEST_F(TestCApiBlackSolver, declare_sep_heap)
2206 : : {
2207 : 1 : cvc5_set_logic(d_solver, "ALL");
2208 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2209 : 1 : cvc5_declare_sep_heap(d_solver, d_int, d_int);
2210 : : // cannot declare separation logic heap more than once
2211 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sep_heap(d_solver, d_int, d_int),
[ - + ][ + - ]
[ + - ][ + - ]
2212 : : "cannot declare heap types");
2213 : :
2214 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2215 : : // no logic set yet
2216 : 1 : Cvc5* slv = cvc5_new(tm);
2217 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sep_heap(d_solver, d_int, d_int),
[ - + ][ + - ]
[ + - ][ + - ]
2218 : : "cannot declare heap types");
2219 : 1 : cvc5_delete(slv);
2220 : :
2221 : 1 : slv = cvc5_new(tm);
2222 : 1 : cvc5_set_logic(slv, "ALL");
2223 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2224 : : cvc5_declare_sep_heap(slv, cvc5_get_integer_sort(tm), d_int),
2225 : : "sort is not associated with the term manager of this solver");
2226 : 1 : cvc5_delete(slv);
2227 : :
2228 : 1 : slv = cvc5_new(tm);
2229 : 1 : cvc5_set_logic(slv, "ALL");
2230 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2231 : : cvc5_declare_sep_heap(slv, d_int, cvc5_get_integer_sort(tm)),
2232 : : "sort is not associated with the term manager of this solver");
2233 : 1 : cvc5_delete(slv);
2234 : 1 : cvc5_term_manager_release(tm);
2235 : 1 : cvc5_term_manager_delete(tm);
2236 : : }
2237 : :
2238 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_heap1)
2239 : : {
2240 : 1 : cvc5_set_logic(d_solver, "QF_BV");
2241 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2242 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2243 : 1 : Cvc5Term t = cvc5_mk_true(d_tm);
2244 : 1 : cvc5_assert_formula(d_solver, t);
2245 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_heap(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
2246 : : "cannot obtain separation logic expressions");
2247 : : }
2248 : :
2249 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_heap2)
2250 : : {
2251 : 1 : cvc5_set_logic(d_solver, "ALL");
2252 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2253 : 1 : cvc5_set_option(d_solver, "produce-models", "false");
2254 : 1 : check_simple_separation_constraints();
2255 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_heap(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
2256 : : "cannot get separation heap term");
2257 : : }
2258 : :
2259 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_heap3)
2260 : : {
2261 : 1 : cvc5_set_logic(d_solver, "ALL");
2262 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2263 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2264 : 1 : Cvc5Term t = cvc5_mk_false(d_tm);
2265 : 1 : cvc5_assert_formula(d_solver, t);
2266 : 1 : cvc5_check_sat(d_solver);
2267 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_heap(d_solver), "after SAT or UNKNOWN");
[ - + ][ + - ]
[ + - ][ + - ]
2268 : : }
2269 : :
2270 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_heap4)
2271 : : {
2272 : 1 : cvc5_set_logic(d_solver, "ALL");
2273 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2274 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2275 : 1 : Cvc5Term t = cvc5_mk_true(d_tm);
2276 : 1 : cvc5_assert_formula(d_solver, t);
2277 : 1 : cvc5_check_sat(d_solver);
2278 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_heap(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
2279 : : "Failed to obtain heap/nil");
2280 : : }
2281 : :
2282 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_heap5)
2283 : : {
2284 : 1 : cvc5_set_logic(d_solver, "ALL");
2285 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2286 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2287 : 1 : check_simple_separation_constraints();
2288 : 1 : (void)cvc5_get_value_sep_heap(d_solver);
2289 : 1 : }
2290 : :
2291 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_nil1)
2292 : : {
2293 : 1 : cvc5_set_logic(d_solver, "QF_BV");
2294 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2295 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2296 : 1 : Cvc5Term t = cvc5_mk_true(d_tm);
2297 : 1 : cvc5_assert_formula(d_solver, t);
2298 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_nil(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
2299 : : "cannot obtain separation logic expressions");
2300 : : }
2301 : :
2302 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_nil2)
2303 : : {
2304 : 1 : cvc5_set_logic(d_solver, "ALL");
2305 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2306 : 1 : cvc5_set_option(d_solver, "produce-models", "false");
2307 : 1 : check_simple_separation_constraints();
2308 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_nil(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
2309 : : "cannot get separation nil");
2310 : : }
2311 : :
2312 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_nil3)
2313 : : {
2314 : 1 : cvc5_set_logic(d_solver, "ALL");
2315 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2316 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2317 : 1 : Cvc5Term t = cvc5_mk_false(d_tm);
2318 : 1 : cvc5_assert_formula(d_solver, t);
2319 : 1 : cvc5_check_sat(d_solver);
2320 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_nil(d_solver), "after SAT or UNKNOWN");
[ - + ][ + - ]
[ + - ][ + - ]
2321 : : }
2322 : :
2323 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_nil4)
2324 : : {
2325 : 1 : cvc5_set_logic(d_solver, "ALL");
2326 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2327 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2328 : 1 : Cvc5Term t = cvc5_mk_true(d_tm);
2329 : 1 : cvc5_assert_formula(d_solver, t);
2330 : 1 : cvc5_check_sat(d_solver);
2331 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_value_sep_nil(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
2332 : : "Failed to obtain heap/nil expressions");
2333 : : }
2334 : :
2335 : 4 : TEST_F(TestCApiBlackSolver, get_value_sep_nil5)
2336 : : {
2337 : 1 : cvc5_set_logic(d_solver, "ALL");
2338 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2339 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2340 : 1 : check_simple_separation_constraints();
2341 : 1 : cvc5_get_value_sep_nil(d_solver);
2342 : 1 : }
2343 : :
2344 : 4 : TEST_F(TestCApiBlackSolver, push1)
2345 : : {
2346 : 1 : cvc5_set_option(d_solver, "incremental", "true");
2347 : 1 : cvc5_push(d_solver, 1);
2348 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(d_solver, "incremental", "false"),
[ - + ][ + - ]
[ + - ][ + - ]
2349 : : "is already fully initialized");
2350 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(d_solver, "incremental", "true"),
[ - + ][ + - ]
[ + - ][ + - ]
2351 : : "is already fully initialized");
2352 : : }
2353 : :
2354 : 4 : TEST_F(TestCApiBlackSolver, push2)
2355 : : {
2356 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2357 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_push(d_solver, 1), "cannot push");
[ - + ][ + - ]
[ + - ][ + - ]
2358 : : }
2359 : :
2360 : 4 : TEST_F(TestCApiBlackSolver, push3)
2361 : : {
2362 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2363 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_push(nullptr, 1), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
2364 : : }
2365 : :
2366 : 4 : TEST_F(TestCApiBlackSolver, pop1)
2367 : : {
2368 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2369 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_pop(d_solver, 1), "cannot pop");
[ - + ][ + - ]
[ + - ][ + - ]
2370 : : }
2371 : :
2372 : 4 : TEST_F(TestCApiBlackSolver, pop2)
2373 : : {
2374 : 1 : cvc5_set_option(d_solver, "incremental", "true");
2375 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_pop(d_solver, 1), "cannot pop");
[ - + ][ + - ]
[ + - ][ + - ]
2376 : : }
2377 : :
2378 : 4 : TEST_F(TestCApiBlackSolver, pop3)
2379 : : {
2380 : 1 : cvc5_set_option(d_solver, "incremental", "true");
2381 : 1 : cvc5_push(d_solver, 1);
2382 : 1 : cvc5_pop(d_solver, 1);
2383 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_pop(d_solver, 1), "cannot pop");
[ - + ][ + - ]
[ + - ][ + - ]
2384 : : }
2385 : :
2386 : 4 : TEST_F(TestCApiBlackSolver, pop4)
2387 : : {
2388 : 1 : cvc5_set_option(d_solver, "incremental", "false");
2389 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_pop(nullptr, 1), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
2390 : : }
2391 : :
2392 : 4 : TEST_F(TestCApiBlackSolver, set_info)
2393 : : {
2394 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, "cvc5-lagic", "QF_BV"),
[ - + ][ + - ]
[ + - ][ + - ]
2395 : : "unrecognized keyword");
2396 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, "cvc2-logic", "QF_BV"),
[ - + ][ + - ]
[ + - ][ + - ]
2397 : : "unrecognized keyword");
2398 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, "cvc5-logic", "asdf"),
[ - + ][ + - ]
[ + - ][ + - ]
2399 : : "unrecognized keyword");
2400 : :
2401 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(nullptr, "source", "asdf"),
[ - + ][ + - ]
[ + - ][ + - ]
2402 : : "unexpected NULL argument");
2403 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, nullptr, "asdf"),
[ - + ][ + - ]
[ + - ][ + - ]
2404 : : "unexpected NULL argument");
2405 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, "source", nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
2406 : : "unexpected NULL argument");
2407 : :
2408 : 1 : cvc5_set_info(d_solver, "source", "asdf");
2409 : 1 : cvc5_set_info(d_solver, "category", "asdf");
2410 : 1 : cvc5_set_info(d_solver, "difficulty", "asdf");
2411 : 1 : cvc5_set_info(d_solver, "filename", "asdf");
2412 : 1 : cvc5_set_info(d_solver, "license", "asdf");
2413 : 1 : cvc5_set_info(d_solver, "name", "asdf");
2414 : 1 : cvc5_set_info(d_solver, "notes", "asdf");
2415 : :
2416 : 1 : cvc5_set_info(d_solver, "smt-lib-version", "2");
2417 : 1 : cvc5_set_info(d_solver, "smt-lib-version", "2.0");
2418 : 1 : cvc5_set_info(d_solver, "smt-lib-version", "2.5");
2419 : 1 : cvc5_set_info(d_solver, "smt-lib-version", "2.6");
2420 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, "smt-lib-version", ".0"),
[ - + ][ + - ]
[ + - ][ + - ]
2421 : : "invalid argument");
2422 : :
2423 : 1 : cvc5_set_info(d_solver, "status", "sat");
2424 : 1 : cvc5_set_info(d_solver, "status", "unsat");
2425 : 1 : cvc5_set_info(d_solver, "status", "unknown");
2426 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_info(d_solver, "status", "asdf"),
[ - + ][ + - ]
[ + - ][ + - ]
2427 : : "invalid argument");
2428 : : }
2429 : :
2430 : 4 : TEST_F(TestCApiBlackSolver, set_logic)
2431 : : {
2432 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_logic(nullptr, "AUFLIRA"),
[ - + ][ + - ]
[ + - ][ + - ]
2433 : : "unexpected NULL argument");
2434 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_logic(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
2435 : : "unexpected NULL argument");
2436 : :
2437 : 1 : cvc5_set_logic(d_solver, "AUFLIRA");
2438 : :
2439 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_logic(d_solver, "AF_BV"), "logic is already set");
[ - + ][ + - ]
[ + - ][ + - ]
2440 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_true(d_tm));
2441 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_logic(d_solver, "AUFLIRA"),
[ - + ][ + - ]
[ + - ][ + - ]
2442 : : "logic is already set");
2443 : : }
2444 : :
2445 : 4 : TEST_F(TestCApiBlackSolver, is_logic_set)
2446 : : {
2447 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_is_logic_set(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
2448 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_is_logic_set(d_solver));
2449 : 1 : cvc5_set_logic(d_solver, "QF_BV");
2450 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_is_logic_set(d_solver));
2451 : : }
2452 : :
2453 : 4 : TEST_F(TestCApiBlackSolver, get_logic)
2454 : : {
2455 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_logic(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
2456 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_logic(d_solver), "logic has not yet been set");
[ - + ][ + - ]
[ + - ][ + - ]
2457 : 1 : cvc5_set_logic(d_solver, "QF_BV");
2458 [ - + ][ + - ]: 1 : ASSERT_EQ(cvc5_get_logic(d_solver), std::string("QF_BV"));
2459 : : }
2460 : :
2461 : 4 : TEST_F(TestCApiBlackSolver, set_option)
2462 : : {
2463 : 1 : cvc5_set_option(d_solver, "bv-sat-solver", "cadical");
2464 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(d_solver, "bv-sat-solver", "1"),
[ - + ][ + - ]
[ + - ][ + - ]
2465 : : "unknown option");
2466 : 1 : cvc5_assert_formula(d_solver, cvc5_mk_true(d_tm));
2467 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(d_solver, "bv-sat-solver", "cadical"),
[ - + ][ + - ]
[ + - ][ + - ]
2468 : : "fully initialized");
2469 : : }
2470 : :
2471 : 4 : TEST_F(TestCApiBlackSolver, reset_assertions)
2472 : : {
2473 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(nullptr, "incremental", "true"),
[ - + ][ + - ]
[ + - ][ + - ]
2474 : : "unexpected NULL argument");
2475 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(d_solver, nullptr, "true"),
[ - + ][ + - ]
[ + - ][ + - ]
2476 : : "unexpected NULL argument");
2477 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_set_option(d_solver, "incremental", nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
2478 : : "unexpected NULL argument");
2479 : :
2480 : 1 : cvc5_set_option(d_solver, "incremental", "true");
2481 : :
2482 : 1 : Cvc5Sort bv_sort = cvc5_mk_bv_sort(d_tm, 4);
2483 : 1 : Cvc5Term one = cvc5_mk_bv_uint64(d_tm, 4, 1);
2484 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, bv_sort, "x");
2485 : 2 : std::vector<Cvc5Term> args = {x, one};
2486 : : Cvc5Term ule =
2487 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_BITVECTOR_ULE, args.size(), args.data());
2488 : 1 : args = {one, x};
2489 : : Cvc5Term srem =
2490 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_BITVECTOR_SREM, args.size(), args.data());
2491 : 1 : cvc5_push(d_solver, 4);
2492 : 1 : args = {srem, one};
2493 : : Cvc5Term slt =
2494 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_BITVECTOR_SLT, args.size(), args.data());
2495 : 1 : cvc5_reset_assertions(d_solver);
2496 : 1 : args = {slt, ule};
2497 : 1 : cvc5_check_sat_assuming(d_solver, args.size(), args.data());
2498 : : }
2499 : :
2500 : 4 : TEST_F(TestCApiBlackSolver, declare_sygus_var)
2501 : : {
2502 : 1 : cvc5_set_option(d_solver, "sygus", "true");
2503 : :
2504 : 1 : std::vector<Cvc5Sort> domain = {d_int};
2505 : : Cvc5Sort fun_sort =
2506 : 1 : cvc5_mk_fun_sort(d_tm, domain.size(), domain.data(), d_bool);
2507 : :
2508 : 1 : (void)cvc5_declare_sygus_var(d_solver, "", d_bool);
2509 : 1 : (void)cvc5_declare_sygus_var(d_solver, "", fun_sort);
2510 : 1 : (void)cvc5_declare_sygus_var(d_solver, "b", d_bool);
2511 : :
2512 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sygus_var(nullptr, "", d_bool),
[ - + ][ + - ]
[ + - ][ + - ]
2513 : : "unexpected NULL argument");
2514 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sygus_var(d_solver, nullptr, d_bool),
[ - + ][ + - ]
[ + - ][ + - ]
2515 : : "unexpected NULL argument");
2516 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sygus_var(d_solver, "", nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
2517 : : "invalid sort");
2518 : :
2519 : 1 : Cvc5* slv = cvc5_new(d_tm);
2520 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_sygus_var(slv, "", d_bool), "cannot call");
[ - + ][ + - ]
[ + - ][ + - ]
2521 : 1 : cvc5_delete(slv);
2522 : :
2523 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2524 : 1 : slv = cvc5_new(tm);
2525 : 1 : cvc5_set_option(slv, "sygus", "true");
2526 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2527 : : cvc5_declare_sygus_var(slv, "", d_bool),
2528 : : "sort is not associated with the term manager of this solver");
2529 : 1 : cvc5_delete(slv);
2530 : 1 : cvc5_term_manager_release(tm);
2531 : 1 : cvc5_term_manager_delete(tm);
2532 [ + - ]: 1 : }
2533 : :
2534 : 4 : TEST_F(TestCApiBlackSolver, mk_grammar)
2535 : : {
2536 : 1 : Cvc5Term bt = cvc5_mk_true(d_tm);
2537 : 1 : Cvc5Term bv = cvc5_mk_var(d_tm, d_bool, "b");
2538 : 1 : Cvc5Term iv = cvc5_mk_var(d_tm, d_int, "i");
2539 : :
2540 : 1 : std::vector<Cvc5Term> bvars;
2541 : 1 : std::vector<Cvc5Term> symbols = {iv};
2542 : 2 : (void)cvc5_mk_grammar(
2543 : 2 : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data());
2544 : 1 : bvars = {bv};
2545 : 2 : (void)cvc5_mk_grammar(
2546 : 2 : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data());
2547 : :
2548 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2549 : : cvc5_mk_grammar(
2550 : : nullptr, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2551 : : "unexpected NULL argument");
2552 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2553 : : cvc5_mk_grammar(
2554 : : d_solver, bvars.size(), bvars.data(), symbols.size(), nullptr),
2555 : : "unexpected NULL argument");
2556 : :
2557 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2558 : : cvc5_mk_grammar(
2559 : : d_solver, bvars.size(), nullptr, symbols.size(), symbols.data()),
2560 : : "unexpected NULL argument");
2561 : :
2562 : 1 : symbols = {nullptr};
2563 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2564 : : cvc5_mk_grammar(
2565 : : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2566 : : "invalid term at index 0");
2567 : 1 : bvars = {nullptr};
2568 : 1 : symbols = {iv};
2569 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2570 : : cvc5_mk_grammar(
2571 : : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2572 : : "invalid term at index 0");
2573 : 1 : bvars = {};
2574 : 1 : symbols = {bt};
2575 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2576 : : cvc5_mk_grammar(
2577 : : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2578 : : "expected a bound variable");
2579 : 1 : bvars = {bt};
2580 : 1 : symbols = {iv};
2581 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2582 : : cvc5_mk_grammar(
2583 : : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2584 : : "expected a bound variable");
2585 : :
2586 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2587 : 1 : Cvc5* slv = cvc5_new(tm);
2588 : 1 : bvars = {};
2589 : 1 : symbols = {iv};
2590 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2591 : : cvc5_mk_grammar(
2592 : : slv, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2593 : : "expected a term associated with the term manager of this solver");
2594 : 1 : bvars = {bv};
2595 : 1 : symbols = {cvc5_mk_var(tm, cvc5_get_integer_sort(tm), "")};
2596 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2597 : : cvc5_mk_grammar(
2598 : : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data()),
2599 : : "expected a term associated with the term manager of this solver");
2600 : 1 : cvc5_delete(slv);
2601 : 1 : cvc5_term_manager_release(tm);
2602 : 1 : cvc5_term_manager_delete(tm);
2603 [ + - ][ + - ]: 1 : }
2604 : :
2605 : 4 : TEST_F(TestCApiBlackSolver, synth_fun)
2606 : : {
2607 : 1 : cvc5_set_option(d_solver, "sygus", "true");
2608 : :
2609 : 1 : Cvc5Term x = cvc5_mk_var(d_tm, d_bool, "");
2610 : 1 : Cvc5Term start1 = cvc5_mk_var(d_tm, d_bool, "");
2611 : 1 : Cvc5Term start2 = cvc5_mk_var(d_tm, d_int, "");
2612 : :
2613 : 1 : std::vector<Cvc5Term> bvars{x};
2614 : 1 : std::vector<Cvc5Term> symbols{start1};
2615 : 2 : Cvc5Grammar g1 = cvc5_mk_grammar(
2616 : 2 : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data());
2617 : :
2618 : 1 : (void)cvc5_synth_fun(d_solver, "", 0, nullptr, d_bool);
2619 : 1 : (void)cvc5_synth_fun(d_solver, "f1", bvars.size(), bvars.data(), d_bool);
2620 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2621 : : cvc5_synth_fun(d_solver, "f3", bvars.size(), nullptr, d_bool),
2622 : : "unexpected NULL argument");
2623 : 1 : std::vector<Cvc5Term> null_bvars{nullptr};
2624 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2625 : : cvc5_synth_fun(
2626 : : d_solver, "f4", null_bvars.size(), null_bvars.data(), d_bool),
2627 : : "invalid term at index 0");
2628 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_synth_fun_with_grammar(
[ - + ][ + - ]
[ + - ][ + - ]
2629 : : d_solver, "f2", bvars.size(), bvars.data(), d_bool, g1),
2630 : : "invalid grammar");
2631 : :
2632 : 1 : cvc5_grammar_add_rule(g1, start1, cvc5_mk_false(d_tm));
2633 : :
2634 : 1 : symbols = {start2};
2635 : 2 : Cvc5Grammar g2 = cvc5_mk_grammar(
2636 : 2 : d_solver, bvars.size(), bvars.data(), symbols.size(), symbols.data());
2637 : 1 : cvc5_grammar_add_rule(g2, start2, cvc5_mk_integer_int64(d_tm, 0));
2638 : :
2639 : 1 : cvc5_synth_fun_with_grammar(
2640 : 1 : d_solver, "f2", bvars.size(), bvars.data(), d_bool, g1);
2641 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_synth_fun_with_grammar(
[ - + ][ + - ]
[ + - ][ + - ]
2642 : : nullptr, "f2", bvars.size(), bvars.data(), d_bool, g1),
2643 : : "unexpected NULL argument");
2644 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2645 : : cvc5_synth_fun_with_grammar(
2646 : : d_solver, "f2", bvars.size(), bvars.data(), nullptr, g1),
2647 : : "invalid sort");
2648 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2649 : : cvc5_synth_fun_with_grammar(
2650 : : d_solver, "f2", bvars.size(), bvars.data(), d_bool, nullptr),
2651 : : "invalid grammar");
2652 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_synth_fun_with_grammar(
[ - + ][ + - ]
[ + - ][ + - ]
2653 : : d_solver, "f2", bvars.size(), nullptr, d_bool, g1),
2654 : : "unexpected NULL argument");
2655 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2656 : : cvc5_synth_fun_with_grammar(
2657 : : d_solver, "f2", null_bvars.size(), null_bvars.data(), d_bool, g1),
2658 : : "invalid term at index 0");
2659 : :
2660 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_synth_fun_with_grammar(
[ - + ][ + - ]
[ + - ][ + - ]
2661 : : d_solver, "f6", bvars.size(), bvars.data(), d_bool, g2),
2662 : : "invalid Start symbol");
2663 : :
2664 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2665 : 1 : Cvc5* slv = cvc5_new(tm);
2666 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2667 : : cvc5_synth_fun_with_grammar(
2668 : : slv, "f8", bvars.size(), bvars.data(), d_bool, g1),
2669 : : "expected a term associated with the term manager of this solver");
2670 : 1 : cvc5_delete(slv);
2671 : 1 : cvc5_term_manager_release(tm);
2672 : 1 : cvc5_term_manager_delete(tm);
2673 [ + - ][ + - ]: 1 : }
2674 : :
2675 : 4 : TEST_F(TestCApiBlackSolver, declare_pool)
2676 : : {
2677 : 1 : Cvc5Sort set_sort = cvc5_mk_set_sort(d_tm, d_int);
2678 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
2679 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
2680 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
2681 : : // declare a pool with initial value { 0, x, y }
2682 : 1 : std::vector<Cvc5Term> args = {zero, x, y};
2683 : : Cvc5Term p =
2684 : 1 : cvc5_declare_pool(d_solver, "p", d_int, args.size(), args.data());
2685 : : // pool should have the same sort
2686 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_sort_is_equal(cvc5_term_get_sort(p), set_sort));
2687 : :
2688 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2689 : : cvc5_declare_pool(nullptr, "p", d_int, args.size(), args.data()),
2690 : : "unexpected NULL argument");
2691 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2692 : : cvc5_declare_pool(d_solver, nullptr, d_int, args.size(), args.data()),
2693 : : "unexpected NULL argument");
2694 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2695 : : cvc5_declare_pool(d_solver, "p", nullptr, args.size(), args.data()),
2696 : : "invalid sort");
2697 : :
2698 : : // no init values is allowed
2699 : 1 : (void)cvc5_declare_pool(d_solver, "p", d_int, 0, nullptr);
2700 : :
2701 : 1 : args = {nullptr, x, y};
2702 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2703 : : cvc5_declare_pool(d_solver, "p", d_int, args.size(), args.data()),
2704 : : "invalid term at index 0");
2705 : 1 : args = {zero, nullptr, y};
2706 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2707 : : cvc5_declare_pool(d_solver, "p", d_int, args.size(), args.data()),
2708 : : "invalid term at index 1");
2709 : 1 : args = {zero, x, nullptr};
2710 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2711 : : cvc5_declare_pool(d_solver, "p", d_int, args.size(), args.data()),
2712 : : "invalid term at index 2");
2713 : :
2714 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2715 : 1 : Cvc5* slv = cvc5_new(tm);
2716 : 1 : args = {zero, x, y};
2717 : 1 : Cvc5Term zero2 = cvc5_mk_integer_int64(tm, 0);
2718 : 1 : Cvc5Term x2 = cvc5_mk_const(tm, cvc5_get_integer_sort(tm), "x");
2719 : 1 : Cvc5Term y2 = cvc5_mk_const(tm, cvc5_get_integer_sort(tm), "y");
2720 : 1 : std::vector<Cvc5Term> args2 = {zero2, x2, y2};
2721 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2722 : : cvc5_declare_pool(slv, "p", d_int, args2.size(), args2.data()),
2723 : : "sort is not associated with the term manager of this solver");
2724 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2725 : : cvc5_declare_pool(
2726 : : slv, "p", cvc5_get_integer_sort(tm), args.size(), args.data()),
2727 : : "expected a term associated with the term manager of this solver");
2728 : 1 : args2 = {zero2, x, y2};
2729 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2730 : : cvc5_declare_pool(
2731 : : slv, "p", cvc5_get_integer_sort(tm), args2.size(), args2.data()),
2732 : : "expected a term associated with the term manager of this solver");
2733 : 1 : cvc5_delete(slv);
2734 : 1 : cvc5_term_manager_release(tm);
2735 : 1 : cvc5_term_manager_delete(tm);
2736 [ + - ]: 1 : }
2737 : :
2738 : 4 : TEST_F(TestCApiBlackSolver, declare_oracle_fun_unsat)
2739 : : {
2740 : 1 : cvc5_set_option(d_solver, "oracles", "true");
2741 : : // f is the function implementing (lambda ((x Int)) (+ x 1))
2742 : 1 : std::vector<Cvc5Sort> sorts = {d_int};
2743 : 2 : Cvc5Term f = cvc5_declare_oracle_fun(
2744 : : d_solver,
2745 : : "f",
2746 : : sorts.size(),
2747 : 1 : sorts.data(),
2748 : : d_int,
2749 : 1 : d_tm,
2750 : 1 : [](size_t, const Cvc5Term* input, void* state) {
2751 : 1 : Cvc5TermManager* ctm = static_cast<Cvc5TermManager*>(state);
2752 [ + - ]: 1 : if (cvc5_term_is_uint32_value(input[0]))
2753 : : {
2754 : 2 : return cvc5_mk_integer_int64(
2755 : 1 : ctm, cvc5_term_get_uint32_value(input[0]) + 1);
2756 : : }
2757 : 0 : return cvc5_mk_integer_int64(ctm, 0);
2758 : : });
2759 : :
2760 : 1 : Cvc5Term three = cvc5_mk_integer_int64(d_tm, 3);
2761 : 1 : Cvc5Term five = cvc5_mk_integer_int64(d_tm, 5);
2762 : 1 : std::vector<Cvc5Term> args = {f, three};
2763 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data()),
2764 : 1 : five};
2765 : 1 : cvc5_assert_formula(
2766 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
2767 : : // (f 3) = 5
2768 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
2769 : :
2770 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
2771 : 1 : Cvc5* slv = cvc5_new(tm);
2772 : 1 : cvc5_set_option(slv, "oracles", "true");
2773 : 1 : Cvc5Sort int_sort = cvc5_get_integer_sort(tm);
2774 : 1 : std::vector<Cvc5Sort> sorts2 = {int_sort};
2775 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2776 : : cvc5_declare_oracle_fun(
2777 : : slv,
2778 : : "f",
2779 : : sorts.size(),
2780 : : sorts.data(),
2781 : : int_sort,
2782 : : tm,
2783 : : [](size_t, const Cvc5Term* input, void* state) {
2784 : : Cvc5TermManager* ctm = static_cast<Cvc5TermManager*>(state);
2785 : : if (cvc5_term_is_uint32_value(input[0]))
2786 : : {
2787 : : return cvc5_mk_integer_int64(
2788 : : ctm, cvc5_term_get_uint32_value(input[0]) + 1);
2789 : : }
2790 : : return cvc5_mk_integer_int64(ctm, 0);
2791 : : }),
2792 : : "expected a sort associated with the term manager of this solver");
2793 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2794 : : cvc5_declare_oracle_fun(
2795 : : slv,
2796 : : "f",
2797 : : sorts2.size(),
2798 : : sorts2.data(),
2799 : : d_int,
2800 : : tm,
2801 : : [](size_t, const Cvc5Term* input, void* state) {
2802 : : Cvc5TermManager* ctm = static_cast<Cvc5TermManager*>(state);
2803 : : if (cvc5_term_is_uint32_value(input[0]))
2804 : : {
2805 : : return cvc5_mk_integer_int64(
2806 : : ctm, cvc5_term_get_uint32_value(input[0]) + 1);
2807 : : }
2808 : : return cvc5_mk_integer_int64(ctm, 0);
2809 : : }),
2810 : : "sort is not associated with the term manager of this solver");
2811 : : // this cannot be caught during declaration, is caught during check-sat
2812 : 2 : Cvc5Term f2 = cvc5_declare_oracle_fun(
2813 : : slv,
2814 : : "f",
2815 : : sorts2.size(),
2816 : 1 : sorts2.data(),
2817 : : int_sort,
2818 : 1 : d_tm,
2819 : 1 : [](size_t, const Cvc5Term* input, void* state) {
2820 : 1 : Cvc5TermManager* ctm = static_cast<Cvc5TermManager*>(state);
2821 [ + - ]: 1 : if (cvc5_term_is_uint32_value(input[0]))
2822 : : {
2823 : 2 : return cvc5_mk_integer_int64(
2824 : 1 : ctm, cvc5_term_get_uint32_value(input[0]) + 1);
2825 : : }
2826 : 0 : return cvc5_mk_integer_int64(ctm, 0);
2827 : : });
2828 : 1 : Cvc5Term three2 = cvc5_mk_integer_int64(tm, 3);
2829 : 1 : Cvc5Term five2 = cvc5_mk_integer_int64(tm, 5);
2830 : 1 : std::vector<Cvc5Term> args2 = {f2, three2};
2831 : 1 : args2 = {cvc5_mk_term(tm, CVC5_KIND_APPLY_UF, args2.size(), args2.data()),
2832 : 1 : five2};
2833 : 1 : cvc5_assert_formula(
2834 : 1 : slv, cvc5_mk_term(tm, CVC5_KIND_EQUAL, args2.size(), args2.data()));
2835 : : // (f 3) = 5
2836 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2837 : : cvc5_check_sat(slv),
2838 : : "Evaluated an oracle call that is not associated with the term "
2839 : : "manager of this solver");
2840 : 1 : cvc5_delete(slv);
2841 : 1 : cvc5_term_manager_release(tm);
2842 : 1 : cvc5_term_manager_delete(tm);
2843 [ + - ][ + - ]: 1 : }
2844 : :
2845 : 4 : TEST_F(TestCApiBlackSolver, declare_oracle_fun_sat)
2846 : : {
2847 : 1 : cvc5_set_option(d_solver, "oracles", "true");
2848 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2849 : : // f is the function implementing (lambda ((x Int)) (% x 10))
2850 : 1 : std::vector<Cvc5Sort> sorts = {d_int};
2851 : 2 : Cvc5Term f = cvc5_declare_oracle_fun(
2852 : : d_solver,
2853 : : "f",
2854 : : sorts.size(),
2855 : 1 : sorts.data(),
2856 : : d_int,
2857 : 1 : d_tm,
2858 : 8 : [](size_t size, const Cvc5Term* input, void* state) {
2859 [ - + ][ - + ]: 8 : Assert(size == 1);
[ - - ]
2860 : 8 : Cvc5TermManager* ctm = static_cast<Cvc5TermManager*>(state);
2861 [ + - ]: 8 : if (cvc5_term_is_uint32_value(input[0]))
2862 : : {
2863 : 16 : return cvc5_mk_integer_int64(
2864 : 8 : ctm, cvc5_term_get_uint32_value(input[0]) % 10);
2865 : : }
2866 : 0 : return cvc5_mk_integer_int64(ctm, 0);
2867 : : });
2868 : 1 : Cvc5Term seven = cvc5_mk_integer_int64(d_tm, 7);
2869 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
2870 : 1 : std::vector<Cvc5Term> args = {x, cvc5_mk_integer_int64(d_tm, 0)};
2871 : 1 : Cvc5Term lb = cvc5_mk_term(d_tm, CVC5_KIND_GEQ, args.size(), args.data());
2872 : 1 : cvc5_assert_formula(d_solver, lb);
2873 : 1 : args = {x, cvc5_mk_integer_int64(d_tm, 100)};
2874 : 1 : Cvc5Term ub = cvc5_mk_term(d_tm, CVC5_KIND_LEQ, args.size(), args.data());
2875 : 1 : cvc5_assert_formula(d_solver, ub);
2876 : 1 : args = {f, x};
2877 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data()),
2878 : 1 : seven};
2879 : 1 : Cvc5Term eq = cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
2880 : 1 : cvc5_assert_formula(d_solver, eq);
2881 : : // x >= 0 ^ x <= 100 ^ (f x) = 7
2882 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
2883 : 1 : Cvc5Term xval = cvc5_get_value(d_solver, x);
2884 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_uint32_value(xval));
2885 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_get_uint32_value(xval) % 10 == 7);
2886 [ + - ][ + - ]: 1 : }
2887 : :
2888 : 4 : TEST_F(TestCApiBlackSolver, declare_oracle_fun_sat2)
2889 : : {
2890 : 1 : cvc5_set_option(d_solver, "oracles", "true");
2891 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
2892 : : // f is the function implementing (lambda ((x Int) (y Int)) (= x y))
2893 : 1 : std::vector<Cvc5Sort> sorts = {d_int, d_int};
2894 : 2 : Cvc5Term eq = cvc5_declare_oracle_fun(
2895 : : d_solver,
2896 : : "eq",
2897 : : sorts.size(),
2898 : 1 : sorts.data(),
2899 : : d_bool,
2900 : 1 : d_tm,
2901 : 2 : [](size_t size, const Cvc5Term* input, void* state) {
2902 [ - + ][ - + ]: 2 : Assert(size == 2);
[ - - ]
2903 : 4 : return cvc5_mk_boolean(static_cast<Cvc5TermManager*>(state),
2904 : 2 : cvc5_term_is_equal(input[0], input[1]));
2905 : : });
2906 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
2907 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
2908 : 1 : std::vector<Cvc5Term> args = {eq, x, y};
2909 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data())};
2910 : 1 : Cvc5Term neq = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
2911 : 1 : cvc5_assert_formula(d_solver, neq);
2912 : : // (not (eq x y))
2913 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
2914 : 1 : Cvc5Term xval = cvc5_get_value(d_solver, x);
2915 : 1 : Cvc5Term yval = cvc5_get_value(d_solver, y);
2916 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(xval, yval));
2917 [ + - ][ + - ]: 1 : }
2918 : :
2919 : 4 : TEST_F(TestCApiBlackSolver, declare_oracle_fun_error1)
2920 : : {
2921 : 1 : cvc5_set_option(d_solver, "oracles", "true");
2922 : 1 : std::vector<Cvc5Sort> sorts = {d_int, d_int};
2923 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_oracle_fun(
[ - + ][ + - ]
[ + - ][ + - ]
2924 : : nullptr,
2925 : : "eq",
2926 : : sorts.size(),
2927 : : sorts.data(),
2928 : : d_bool,
2929 : : d_tm,
2930 : : [](size_t size, const Cvc5Term* input, void* state) {
2931 : : Assert(size == 2);
2932 : : return cvc5_mk_boolean(
2933 : : static_cast<Cvc5TermManager*>(state),
2934 : : cvc5_term_is_equal(input[0], input[1]));
2935 : : }),
2936 : : "unexpected NULL argument");
2937 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_oracle_fun(
[ - + ][ + - ]
[ + - ][ + - ]
2938 : : d_solver,
2939 : : nullptr,
2940 : : sorts.size(),
2941 : : sorts.data(),
2942 : : d_bool,
2943 : : d_tm,
2944 : : [](size_t size, const Cvc5Term* input, void* state) {
2945 : : Assert(size == 2);
2946 : : return cvc5_mk_boolean(
2947 : : static_cast<Cvc5TermManager*>(state),
2948 : : cvc5_term_is_equal(input[0], input[1]));
2949 : : }),
2950 : : "unexpected NULL argument");
2951 : : // Declaring an oracle function with no argument sorts triggers an internal
2952 : : // (debug-only) cvc5 assertion that aborts the process via FatalStream; this
2953 : : // is not a recoverable C API error, so it remains a death test.
2954 : 1 : ASSERT_DEATH(cvc5_declare_oracle_fun(
2955 : : d_solver,
2956 : : "eq",
2957 : : 0,
2958 : : nullptr,
2959 : : d_bool,
2960 : : d_tm,
2961 : : [](size_t size, const Cvc5Term* input, void* state) {
2962 : : Assert(size == 2);
2963 : : return cvc5_mk_boolean(
2964 : : static_cast<Cvc5TermManager*>(state),
2965 : : cvc5_term_is_equal(input[0], input[1]));
2966 : : }),
2967 : : "");
2968 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_declare_oracle_fun(
[ - + ][ + - ]
[ + - ][ + - ]
2969 : : d_solver,
2970 : : "eq",
2971 : : sorts.size(),
2972 : : sorts.data(),
2973 : : nullptr,
2974 : : d_tm,
2975 : : [](size_t size, const Cvc5Term* input, void* state) {
2976 : : Assert(size == 2);
2977 : : return cvc5_mk_boolean(
2978 : : static_cast<Cvc5TermManager*>(state),
2979 : : cvc5_term_is_equal(input[0], input[1]));
2980 : : }),
2981 : : "invalid sort");
2982 : : // this won't die when declaring the function, only when the actual oracle
2983 : : // fun is called
2984 : 2 : (void)cvc5_declare_oracle_fun(
2985 : : d_solver,
2986 : : "eq",
2987 : : sorts.size(),
2988 : 1 : sorts.data(),
2989 : : d_bool,
2990 : : nullptr,
2991 : 0 : [](size_t size, const Cvc5Term* input, void* state) {
2992 : 0 : Assert(size == 2);
2993 : 0 : return cvc5_mk_boolean(static_cast<Cvc5TermManager*>(state),
2994 : 0 : cvc5_term_is_equal(input[0], input[1]));
2995 : : });
2996 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
2997 : : cvc5_declare_oracle_fun(
2998 : : d_solver, "eq", sorts.size(), sorts.data(), d_bool, d_tm, nullptr),
2999 : : "unexpected NULL argument");
3000 [ + - ]: 1 : }
3001 : :
3002 : 4 : TEST_F(TestCApiBlackSolver, declare_oracle_fun_error2)
3003 : : {
3004 : 1 : std::vector<Cvc5Sort> sorts = {d_int};
3005 : : // cannot declare without option
3006 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3007 : : cvc5_declare_oracle_fun(d_solver,
3008 : : "f",
3009 : : sorts.size(),
3010 : : sorts.data(),
3011 : : d_int,
3012 : : d_tm,
3013 : : [](size_t size, const Cvc5Term*, void* state) {
3014 : : Assert(size == 2);
3015 : : return cvc5_mk_integer_int64(
3016 : : static_cast<Cvc5TermManager*>(state), 0);
3017 : : }),
3018 : : "unless oracles is enabled");
3019 [ + - ]: 1 : }
3020 : :
3021 : 4 : TEST_F(TestCApiBlackSolver, get_interpolant)
3022 : : {
3023 : 1 : cvc5_set_logic(d_solver, "QF_LIA");
3024 : 1 : cvc5_set_option(d_solver, "produce-interpolants", "true");
3025 : 1 : cvc5_set_option(d_solver, "incremental", "false");
3026 : :
3027 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
3028 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
3029 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
3030 : 1 : Cvc5Term z = cvc5_mk_const(d_tm, d_int, "z");
3031 : :
3032 : : // Assumptions for interpolation: x + y > 0 /\ x < 0
3033 : 1 : std::vector<Cvc5Term> args = {x, y};
3034 : 1 : Cvc5Term add = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
3035 : 1 : args = {add, zero};
3036 : 1 : cvc5_assert_formula(
3037 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
3038 : 1 : args = {x, zero};
3039 : 1 : cvc5_assert_formula(
3040 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_LT, args.size(), args.data()));
3041 : :
3042 : : // Conjecture for interpolation: y + z > 0 \/ z < 0
3043 : 1 : args = {y, z};
3044 : 1 : add = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
3045 : 1 : args = {add, zero};
3046 : 1 : Cvc5Term gt = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
3047 : 1 : args = {z, zero};
3048 : 1 : Cvc5Term lt = cvc5_mk_term(d_tm, CVC5_KIND_LT, args.size(), args.data());
3049 : 1 : args = {gt, lt};
3050 : 1 : Cvc5Term conj = cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data());
3051 : :
3052 : : // Call the interpolation api, while the resulting interpolant is the output
3053 : 1 : Cvc5Term output = cvc5_get_interpolant(d_solver, conj);
3054 : : // We expect the resulting output to be a boolean formula
3055 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_sort_is_boolean(cvc5_term_get_sort(output)));
3056 : :
3057 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant(nullptr, conj),
[ - + ][ + - ]
[ + - ][ + - ]
3058 : : "unexpected NULL argument");
3059 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
3060 : :
3061 : : // try with a grammar, a simple grammar admitting true
3062 : 1 : Cvc5Term ttrue = cvc5_mk_true(d_tm);
3063 : 1 : Cvc5Term start = cvc5_mk_var(d_tm, d_bool, "start");
3064 : 1 : std::vector<Cvc5Term> symbols = {start};
3065 : : Cvc5Grammar g =
3066 : 1 : cvc5_mk_grammar(d_solver, 0, nullptr, symbols.size(), symbols.data());
3067 : :
3068 : 1 : args = {zero, zero};
3069 : : Cvc5Term conj2 =
3070 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
3071 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant_with_grammar(d_solver, conj2, g),
[ - + ][ + - ]
[ + - ][ + - ]
3072 : : "invalid grammar, must have at least one rule");
3073 : 1 : cvc5_grammar_add_rule(g, start, ttrue);
3074 : :
3075 : : // Call the interpolation api, while the resulting interpolant is the output
3076 : 1 : Cvc5Term output2 = cvc5_get_interpolant_with_grammar(d_solver, conj2, g);
3077 : : // interpolant must be true
3078 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(output2, ttrue));
3079 : :
3080 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant_with_grammar(nullptr, conj2, g),
[ - + ][ + - ]
[ + - ][ + - ]
3081 : : "unexpected NULL argument");
3082 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant_with_grammar(d_solver, nullptr, g),
[ - + ][ + - ]
[ + - ][ + - ]
3083 : : "invalid term");
3084 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant_with_grammar(d_solver, conj2, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3085 : : "invalid grammar");
3086 : :
3087 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3088 : 1 : Cvc5* slv = cvc5_new(tm);
3089 : 1 : cvc5_set_option(slv, "produce-interpolants", "true");
3090 : 1 : Cvc5Term zzero = cvc5_mk_integer_int64(tm, 0);
3091 : 1 : Cvc5Term sstart = cvc5_mk_var(tm, cvc5_get_boolean_sort(tm), "start");
3092 : 1 : std::vector<Cvc5Term> ssymbols = {sstart};
3093 : : Cvc5Grammar gg =
3094 : 1 : cvc5_mk_grammar(slv, 0, nullptr, ssymbols.size(), ssymbols.data());
3095 : 1 : cvc5_grammar_add_rule(gg, sstart, cvc5_mk_true(tm));
3096 : 1 : std::vector<Cvc5Term> aargs = {zzero, zzero};
3097 : : Cvc5Term cconj2 =
3098 : 1 : cvc5_mk_term(tm, CVC5_KIND_EQUAL, aargs.size(), aargs.data());
3099 : 1 : (void)cvc5_get_interpolant_with_grammar(slv, cconj2, gg);
3100 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3101 : : cvc5_get_interpolant(slv, conj2),
3102 : : "term is not associated with the term manager of this solver");
3103 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3104 : : cvc5_get_interpolant_with_grammar(slv, conj2, gg),
3105 : : "term is not associated with the term manager of this solver");
3106 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3107 : : cvc5_get_interpolant_with_grammar(slv, cconj2, g),
3108 : : "grammar is not associated with the term manager of this solver");
3109 : 1 : cvc5_delete(slv);
3110 : 1 : cvc5_term_manager_release(tm);
3111 : 1 : cvc5_term_manager_delete(tm);
3112 [ + - ]: 1 : }
3113 : :
3114 : 4 : TEST_F(TestCApiBlackSolver, get_interpolant_next)
3115 : : {
3116 : 1 : cvc5_set_logic(d_solver, "QF_LIA");
3117 : 1 : cvc5_set_option(d_solver, "produce-interpolants", "true");
3118 : 1 : cvc5_set_option(d_solver, "incremental", "true");
3119 : :
3120 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
3121 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
3122 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
3123 : 1 : Cvc5Term z = cvc5_mk_const(d_tm, d_int, "z");
3124 : :
3125 : : // Assumptions for interpolation: x + y > 0 /\ x < 0
3126 : 1 : std::vector<Cvc5Term> args = {x, y};
3127 : 1 : Cvc5Term add = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
3128 : 1 : args = {add, zero};
3129 : 1 : cvc5_assert_formula(
3130 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
3131 : 1 : args = {x, zero};
3132 : 1 : cvc5_assert_formula(
3133 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_LT, args.size(), args.data()));
3134 : : // Conjecture for interpolation: y + z > 0 \/ z < 0
3135 : 1 : args = {y, z};
3136 : 1 : add = cvc5_mk_term(d_tm, CVC5_KIND_ADD, args.size(), args.data());
3137 : 1 : args = {add, zero};
3138 : 1 : Cvc5Term gt = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
3139 : 1 : args = {z, zero};
3140 : 1 : Cvc5Term lt = cvc5_mk_term(d_tm, CVC5_KIND_LT, args.size(), args.data());
3141 : 1 : args = {gt, lt};
3142 : 1 : Cvc5Term conj = cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data());
3143 : :
3144 : 1 : Cvc5Term output = cvc5_get_interpolant(d_solver, conj);
3145 : 1 : Cvc5Term output2 = cvc5_get_interpolant_next(d_solver);
3146 : :
3147 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant(nullptr, conj),
[ - + ][ + - ]
[ + - ][ + - ]
3148 : : "unexpected NULL argument");
3149 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
3150 : :
3151 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_interpolant_next(nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3152 : : "unexpected NULL argument");
3153 : :
3154 : : // We expect the next output to be distinct
3155 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(output, output2));
3156 [ + - ]: 1 : }
3157 : :
3158 : 4 : TEST_F(TestCApiBlackSolver, get_abduct)
3159 : : {
3160 : 1 : cvc5_set_logic(d_solver, "QF_LIA");
3161 : 1 : cvc5_set_option(d_solver, "produce-abducts", "true");
3162 : 1 : cvc5_set_option(d_solver, "incremental", "false");
3163 : :
3164 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
3165 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
3166 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
3167 : :
3168 : : // Assumptions for abduction: x > 0
3169 : 1 : std::vector<Cvc5Term> args = {x, zero};
3170 : 1 : cvc5_assert_formula(
3171 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
3172 : : // Conjecture for abduction: y > 0
3173 : 1 : args = {y, zero};
3174 : 1 : Cvc5Term conj = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
3175 : : // Call the abduction api, while the resulting abduct is the output
3176 : 1 : Cvc5Term output = cvc5_get_abduct(d_solver, conj);
3177 : : // We expect the resulting output to be a boolean formula
3178 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_sort_is_boolean(cvc5_term_get_sort(output)));
3179 : :
3180 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct(nullptr, conj), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3181 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
3182 : :
3183 : : // try with a grammar, a simple grammar admitting true
3184 : 1 : Cvc5Term ttrue = cvc5_mk_true(d_tm);
3185 : 1 : Cvc5Term start = cvc5_mk_var(d_tm, d_bool, "start");
3186 : 1 : std::vector<Cvc5Term> symbols = {start};
3187 : : Cvc5Grammar g =
3188 : 1 : cvc5_mk_grammar(d_solver, 0, nullptr, symbols.size(), symbols.data());
3189 : 1 : args = {x, zero};
3190 : 1 : Cvc5Term conj2 = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
3191 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct_with_grammar(d_solver, conj2, g),
[ - + ][ + - ]
[ + - ][ + - ]
3192 : : "invalid grammar, must have at least one rule");
3193 : 1 : cvc5_grammar_add_rule(g, start, ttrue);
3194 : :
3195 : : // Call the abduction api, while the resulting abduct is the output
3196 : 1 : Cvc5Term output2 = cvc5_get_abduct_with_grammar(d_solver, conj2, g);
3197 : : // abduct must be true
3198 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(output2, ttrue));
3199 : :
3200 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct_with_grammar(nullptr, conj2, g),
[ - + ][ + - ]
[ + - ][ + - ]
3201 : : "unexpected NULL argument");
3202 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct_with_grammar(d_solver, nullptr, g),
[ - + ][ + - ]
[ + - ][ + - ]
3203 : : "invalid term");
3204 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct_with_grammar(d_solver, conj2, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3205 : : "invalid grammar");
3206 : :
3207 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3208 : 1 : Cvc5* slv = cvc5_new(tm);
3209 : 1 : cvc5_set_option(slv, "produce-abducts", "true");
3210 : 1 : Cvc5Sort int_sort = cvc5_get_integer_sort(tm);
3211 : 1 : Cvc5Term zzero = cvc5_mk_integer_int64(tm, 0);
3212 : 1 : Cvc5Term xx = cvc5_mk_const(tm, int_sort, "x");
3213 : 1 : Cvc5Term yy = cvc5_mk_const(tm, int_sort, "y");
3214 : 1 : Cvc5Term sstart = cvc5_mk_var(tm, cvc5_get_boolean_sort(tm), "start");
3215 : 1 : args = {xx, yy};
3216 : 1 : Cvc5Term add = cvc5_mk_term(tm, CVC5_KIND_ADD, args.size(), args.data());
3217 : 1 : args = {add, zzero};
3218 : 1 : cvc5_assert_formula(slv,
3219 : 1 : cvc5_mk_term(tm, CVC5_KIND_GT, args.size(), args.data()));
3220 : 1 : std::vector<Cvc5Term> ssymbols = {sstart};
3221 : : Cvc5Grammar gg =
3222 : 1 : cvc5_mk_grammar(slv, 0, nullptr, ssymbols.size(), ssymbols.data());
3223 : 1 : cvc5_grammar_add_rule(gg, sstart, cvc5_mk_true(tm));
3224 : 1 : std::vector<Cvc5Term> aargs = {zzero, zzero};
3225 : : Cvc5Term cconj2 =
3226 : 1 : cvc5_mk_term(tm, CVC5_KIND_EQUAL, aargs.size(), aargs.data());
3227 : 1 : (void)cvc5_get_abduct_with_grammar(slv, cconj2, gg);
3228 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3229 : : cvc5_get_abduct(slv, conj2),
3230 : : "term is not associated with the term manager of this solver");
3231 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3232 : : cvc5_get_abduct_with_grammar(slv, conj2, gg),
3233 : : "term is not associated with the term manager of this solver");
3234 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3235 : : cvc5_get_abduct_with_grammar(slv, cconj2, g),
3236 : : "grammar is not associated with the term manager of this solver");
3237 : 1 : cvc5_delete(slv);
3238 : 1 : cvc5_term_manager_release(tm);
3239 : 1 : cvc5_term_manager_delete(tm);
3240 [ + - ]: 1 : }
3241 : :
3242 : 4 : TEST_F(TestCApiBlackSolver, get_abduct2)
3243 : : {
3244 : 1 : cvc5_set_logic(d_solver, "QF_LIA");
3245 : 1 : cvc5_set_option(d_solver, "incremental", "false");
3246 : :
3247 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
3248 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
3249 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
3250 : : // Assumptions for abduction: x > 0
3251 : 1 : std::vector<Cvc5Term> args = {x, zero};
3252 : 1 : cvc5_assert_formula(
3253 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
3254 : : // Conjecture for abduction: y > 0
3255 : 1 : args = {y, zero};
3256 : 1 : Cvc5Term conj = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
3257 : : // Fails due to option not set
3258 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct(d_solver, conj),
[ - + ][ + - ]
[ + - ][ + - ]
3259 : : "unless abducts are enabled");
3260 [ + - ]: 1 : }
3261 : :
3262 : 4 : TEST_F(TestCApiBlackSolver, get_abduct_next)
3263 : : {
3264 : 1 : cvc5_set_logic(d_solver, "QF_LIA");
3265 : 1 : cvc5_set_option(d_solver, "produce-abducts", "true");
3266 : 1 : cvc5_set_option(d_solver, "incremental", "true");
3267 : :
3268 : 1 : Cvc5Term zero = cvc5_mk_integer_int64(d_tm, 0);
3269 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_int, "x");
3270 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, d_int, "y");
3271 : :
3272 : : // Assumptions for abduction: x > 0
3273 : 1 : std::vector<Cvc5Term> args = {x, zero};
3274 : 1 : cvc5_assert_formula(
3275 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data()));
3276 : : // Conjecture for abduction: y > 0
3277 : 1 : args = {y, zero};
3278 : 1 : Cvc5Term conj = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
3279 : : // Call the abduction api, while the resulting abduct is the output
3280 : 1 : Cvc5Term output = cvc5_get_abduct(d_solver, conj);
3281 : 1 : Cvc5Term output2 = cvc5_get_abduct_next(d_solver);
3282 : :
3283 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct(nullptr, conj), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3284 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
3285 : :
3286 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_abduct_next(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3287 : :
3288 : : // should produce a different output
3289 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_disequal(output, output2));
3290 [ + - ]: 1 : }
3291 : :
3292 : 4 : TEST_F(TestCApiBlackSolver, block_model1)
3293 : : {
3294 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3295 : 1 : std::vector<Cvc5Term> args = {x, x};
3296 : 1 : cvc5_assert_formula(
3297 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3298 : 1 : cvc5_check_sat(d_solver);
3299 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model(d_solver, CVC5_BLOCK_MODELS_MODE_LITERALS),
[ - + ][ + - ]
[ + - ][ + - ]
3300 : : "cannot get value");
3301 [ + - ]: 1 : }
3302 : :
3303 : 4 : TEST_F(TestCApiBlackSolver, block_model2)
3304 : : {
3305 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
3306 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3307 : 1 : std::vector<Cvc5Term> args = {x, x};
3308 : 1 : cvc5_assert_formula(
3309 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3310 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model(d_solver, CVC5_BLOCK_MODELS_MODE_LITERALS),
[ - + ][ + - ]
[ + - ][ + - ]
3311 : : "after SAT or UNKNOWN");
3312 [ + - ]: 1 : }
3313 : :
3314 : 4 : TEST_F(TestCApiBlackSolver, block_model3)
3315 : : {
3316 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
3317 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3318 : 1 : std::vector<Cvc5Term> args = {x, x};
3319 : 1 : cvc5_assert_formula(
3320 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3321 : 1 : cvc5_check_sat(d_solver);
3322 : 1 : cvc5_block_model(d_solver, CVC5_BLOCK_MODELS_MODE_LITERALS);
3323 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model(nullptr, CVC5_BLOCK_MODELS_MODE_LITERALS),
[ - + ][ + - ]
[ + - ][ + - ]
3324 : : "unexpected NULL argument");
3325 [ + - ]: 1 : }
3326 : :
3327 : 4 : TEST_F(TestCApiBlackSolver, block_model_values1)
3328 : : {
3329 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
3330 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3331 : 1 : std::vector<Cvc5Term> args = {x, x};
3332 : 1 : cvc5_assert_formula(
3333 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3334 : 1 : cvc5_check_sat(d_solver);
3335 : 1 : args = {cvc5_mk_true(d_tm)};
3336 : 1 : cvc5_block_model_values(d_solver, args.size(), args.data());
3337 : :
3338 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model_values(nullptr, args.size(), args.data()),
[ - + ][ + - ]
[ + - ][ + - ]
3339 : : "unexpected NULL argument");
3340 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model_values(d_solver, 0, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3341 : : "unexpected NULL argument");
3342 : 1 : args = {nullptr};
3343 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model_values(d_solver, args.size(), args.data()),
[ - + ][ + - ]
[ + - ][ + - ]
3344 : : "invalid term at index 0");
3345 : :
3346 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3347 : 1 : Cvc5* slv = cvc5_new(tm);
3348 : 1 : cvc5_set_option(slv, "produce-models", "true");
3349 : 1 : cvc5_check_sat(slv);
3350 : 1 : args = {cvc5_mk_true(d_tm)};
3351 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3352 : : cvc5_block_model_values(slv, args.size(), args.data()),
3353 : : "expected a term associated with the term manager of this solver");
3354 : 1 : cvc5_delete(slv);
3355 : 1 : cvc5_term_manager_release(tm);
3356 : 1 : cvc5_term_manager_delete(tm);
3357 [ + - ]: 1 : }
3358 : :
3359 : 4 : TEST_F(TestCApiBlackSolver, block_model_values2)
3360 : : {
3361 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
3362 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3363 : 1 : std::vector<Cvc5Term> args = {x, x};
3364 : 1 : cvc5_assert_formula(
3365 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3366 : 1 : cvc5_check_sat(d_solver);
3367 : 1 : args = {x};
3368 : 1 : cvc5_block_model_values(d_solver, args.size(), args.data());
3369 : 1 : }
3370 : :
3371 : 4 : TEST_F(TestCApiBlackSolver, block_model_values3)
3372 : : {
3373 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3374 : 1 : std::vector<Cvc5Term> args = {x, x};
3375 : 1 : cvc5_assert_formula(
3376 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3377 : 1 : cvc5_check_sat(d_solver);
3378 : 1 : args = {x};
3379 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model_values(d_solver, args.size(), args.data()),
[ - + ][ + - ]
[ + - ][ + - ]
3380 : : "cannot get value");
3381 [ + - ]: 1 : }
3382 : :
3383 : 4 : TEST_F(TestCApiBlackSolver, block_model_values4)
3384 : : {
3385 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
3386 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3387 : 1 : std::vector<Cvc5Term> args = {x, x};
3388 : 1 : cvc5_assert_formula(
3389 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3390 : 1 : args = {x};
3391 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_block_model_values(d_solver, args.size(), args.data()),
[ - + ][ + - ]
[ + - ][ + - ]
3392 : : "SAT or UNKNOWN response");
3393 [ + - ]: 1 : }
3394 : :
3395 : 4 : TEST_F(TestCApiBlackSolver, block_model_values5)
3396 : : {
3397 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
3398 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, d_bool, "x");
3399 : 1 : std::vector<Cvc5Term> args = {x, x};
3400 : 1 : cvc5_assert_formula(
3401 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
3402 : 1 : cvc5_check_sat(d_solver);
3403 : 1 : args = {x};
3404 : 1 : cvc5_block_model_values(d_solver, args.size(), args.data());
3405 : 1 : }
3406 : :
3407 : 4 : TEST_F(TestCApiBlackSolver, get_instantiations)
3408 : : {
3409 : 1 : std::vector<Cvc5Sort> sorts = {d_int};
3410 : : Cvc5Term p =
3411 : 1 : cvc5_declare_fun(d_solver, "p", sorts.size(), sorts.data(), d_bool, true);
3412 : 1 : Cvc5Term x = cvc5_mk_var(d_tm, d_int, "x");
3413 : 1 : std::vector<Cvc5Term> args = {x};
3414 : : Cvc5Term bvl =
3415 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_VARIABLE_LIST, args.size(), args.data());
3416 : 1 : args = {p, x};
3417 : : Cvc5Term app =
3418 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
3419 : 1 : args = {bvl, app};
3420 : 1 : Cvc5Term q = cvc5_mk_term(d_tm, CVC5_KIND_FORALL, args.size(), args.data());
3421 : 1 : cvc5_assert_formula(d_solver, q);
3422 : 1 : Cvc5Term five = cvc5_mk_integer_int64(d_tm, 5);
3423 : 1 : args = {p, five};
3424 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data())};
3425 : 1 : Cvc5Term app2 = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
3426 : 1 : cvc5_assert_formula(d_solver, app2);
3427 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_instantiations(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
3428 : : "after a UNSAT, SAT or UNKNOWN response");
3429 : 1 : cvc5_check_sat(d_solver);
3430 : 1 : cvc5_get_instantiations(d_solver);
3431 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_instantiations(nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3432 : : "unexpected NULL argument");
3433 [ + - ][ + - ]: 1 : }
3434 : :
3435 : 4 : TEST_F(TestCApiBlackSolver, add_sygus_constraint)
3436 : : {
3437 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3438 : 1 : Cvc5Term tbool = cvc5_mk_true(d_tm);
3439 : :
3440 : 1 : cvc5_add_sygus_constraint(d_solver, tbool);
3441 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_add_sygus_constraint(nullptr, tbool),
[ - + ][ + - ]
[ + - ][ + - ]
3442 : : "unexpected NULL argument");
3443 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_add_sygus_constraint(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3444 : : "invalid term");
3445 : :
3446 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3447 : 1 : Cvc5* slv = cvc5_new(tm);
3448 : 1 : cvc5_set_option(slv, "sygus", "true");
3449 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3450 : : cvc5_add_sygus_constraint(slv, tbool),
3451 : : "term is not associated with the term manager of this solver");
3452 : 1 : cvc5_delete(slv);
3453 : 1 : cvc5_term_manager_release(tm);
3454 : 1 : cvc5_term_manager_delete(tm);
3455 : : }
3456 : :
3457 : 4 : TEST_F(TestCApiBlackSolver, get_sygus_constraints)
3458 : : {
3459 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3460 : 1 : Cvc5Term ttrue = cvc5_mk_true(d_tm);
3461 : 1 : Cvc5Term tfalse = cvc5_mk_false(d_tm);
3462 : 1 : cvc5_add_sygus_constraint(d_solver, ttrue);
3463 : 1 : cvc5_add_sygus_constraint(d_solver, tfalse);
3464 : : size_t size;
3465 : 1 : const Cvc5Term* constraints = cvc5_get_sygus_constraints(d_solver, &size);
3466 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(ttrue, constraints[0]));
3467 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(tfalse, constraints[1]));
3468 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_sygus_constraints(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
3469 : : "unexpected NULL argument");
3470 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_sygus_constraints(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3471 : : "unexpected NULL argument");
3472 : : }
3473 : :
3474 : 4 : TEST_F(TestCApiBlackSolver, add_sygus_assume)
3475 : : {
3476 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3477 : 1 : Cvc5Term tbool = cvc5_mk_false(d_tm);
3478 : 1 : Cvc5Term tint = cvc5_mk_integer_int64(d_tm, 1);
3479 : :
3480 : 1 : cvc5_add_sygus_assume(d_solver, tbool);
3481 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_add_sygus_assume(nullptr, tbool),
[ - + ][ + - ]
[ + - ][ + - ]
3482 : : "unexpected NULL argument");
3483 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_add_sygus_assume(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
3484 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_add_sygus_assume(d_solver, tint), "invalid argument");
[ - + ][ + - ]
[ + - ][ + - ]
3485 : :
3486 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3487 : 1 : Cvc5* slv = cvc5_new(tm);
3488 : 1 : cvc5_set_option(slv, "sygus", "true");
3489 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3490 : : cvc5_add_sygus_assume(slv, tbool),
3491 : : "term is not associated with the term manager of this solver");
3492 : 1 : cvc5_delete(slv);
3493 : 1 : cvc5_term_manager_release(tm);
3494 : 1 : cvc5_term_manager_delete(tm);
3495 : : }
3496 : :
3497 : 4 : TEST_F(TestCApiBlackSolver, get_sygus_assumptions)
3498 : : {
3499 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3500 : 1 : Cvc5Term ttrue = cvc5_mk_true(d_tm);
3501 : 1 : Cvc5Term tfalse = cvc5_mk_false(d_tm);
3502 : 1 : cvc5_add_sygus_assume(d_solver, ttrue);
3503 : 1 : cvc5_add_sygus_assume(d_solver, tfalse);
3504 : 1 : cvc5_add_sygus_assume(d_solver, ttrue);
3505 : 1 : cvc5_add_sygus_assume(d_solver, tfalse);
3506 : : size_t size;
3507 : 1 : const Cvc5Term* assumptions = cvc5_get_sygus_assumptions(d_solver, &size);
3508 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(ttrue, assumptions[0]));
3509 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(tfalse, assumptions[1]));
3510 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_sygus_assumptions(nullptr, &size),
[ - + ][ + - ]
[ + - ][ + - ]
3511 : : "unexpected NULL argument");
3512 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_sygus_assumptions(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3513 : : "unexpected NULL argument");
3514 : : }
3515 : :
3516 : 4 : TEST_F(TestCApiBlackSolver, add_sygus_inv_constraint)
3517 : : {
3518 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3519 : 1 : Cvc5Term tint = cvc5_mk_integer_int64(d_tm, 1);
3520 : :
3521 : 1 : std::vector<Cvc5Sort> domain = {d_real};
3522 : 1 : Cvc5Term inv = cvc5_declare_fun(
3523 : 1 : d_solver, "inv", domain.size(), domain.data(), d_bool, true);
3524 : 1 : Cvc5Term pre = cvc5_declare_fun(
3525 : 1 : d_solver, "pre", domain.size(), domain.data(), d_bool, true);
3526 : 1 : domain = {d_real, d_real};
3527 : 1 : Cvc5Term trans = cvc5_declare_fun(
3528 : 1 : d_solver, "trans", domain.size(), domain.data(), d_bool, true);
3529 : 1 : domain = {d_real};
3530 : 1 : Cvc5Term post = cvc5_declare_fun(
3531 : 1 : d_solver, "post", domain.size(), domain.data(), d_bool, true);
3532 : :
3533 : 1 : Cvc5Term inv1 = cvc5_declare_fun(
3534 : 1 : d_solver, "inv1", domain.size(), domain.data(), d_real, true);
3535 : 1 : domain = {d_bool, d_real};
3536 : 1 : Cvc5Term trans1 = cvc5_declare_fun(
3537 : 1 : d_solver, "trans1", domain.size(), domain.data(), d_bool, true);
3538 : 1 : domain = {d_real, d_bool};
3539 : 1 : Cvc5Term trans2 = cvc5_declare_fun(
3540 : 1 : d_solver, "trans2", domain.size(), domain.data(), d_bool, true);
3541 : 1 : domain = {d_real, d_real};
3542 : 1 : Cvc5Term trans3 = cvc5_declare_fun(
3543 : 1 : d_solver, "trans3", domain.size(), domain.data(), d_real, true);
3544 : :
3545 : 1 : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, trans, post);
3546 : :
3547 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3548 : : cvc5_add_sygus_inv_constraint(nullptr, inv, pre, trans, post),
3549 : : "unexpected NULL argument");
3550 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3551 : : cvc5_add_sygus_inv_constraint(d_solver, nullptr, pre, trans, post),
3552 : : "invalid term");
3553 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3554 : : cvc5_add_sygus_inv_constraint(d_solver, inv, nullptr, trans, post),
3555 : : "invalid term");
3556 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3557 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, nullptr, post),
3558 : : "invalid term");
3559 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3560 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, trans, nullptr),
3561 : : "invalid term");
3562 : :
3563 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3564 : : cvc5_add_sygus_inv_constraint(d_solver, tint, pre, trans, post),
3565 : : "invalid argument");
3566 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3567 : : cvc5_add_sygus_inv_constraint(d_solver, inv1, pre, trans, post),
3568 : : "invalid argument");
3569 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3570 : : cvc5_add_sygus_inv_constraint(d_solver, inv, trans, trans, post),
3571 : : "have the same sort");
3572 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3573 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, tint, post),
3574 : : "expected the sort of trans");
3575 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3576 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, pre, post),
3577 : : "expected the sort of trans");
3578 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3579 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, trans1, post),
3580 : : "expected the sort of trans");
3581 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3582 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, trans2, post),
3583 : : "expected the sort of trans");
3584 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3585 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, trans3, post),
3586 : : "expected the sort of trans");
3587 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3588 : : cvc5_add_sygus_inv_constraint(d_solver, inv, pre, trans, trans),
3589 : : "expected inv and post to have the same sort");
3590 : :
3591 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3592 : 1 : Cvc5* slv = cvc5_new(tm);
3593 : 1 : cvc5_set_option(slv, "sygus", "true");
3594 : 1 : Cvc5Sort bool_sort = cvc5_get_boolean_sort(tm);
3595 : 1 : Cvc5Sort real_sort = cvc5_get_real_sort(tm);
3596 : 1 : std::vector<Cvc5Sort> domain2 = {real_sort};
3597 : 1 : Cvc5Term inv22 = cvc5_declare_fun(
3598 : 1 : slv, "inv", domain2.size(), domain2.data(), bool_sort, true);
3599 : 1 : Cvc5Term pre22 = cvc5_declare_fun(
3600 : 1 : slv, "pre", domain2.size(), domain2.data(), bool_sort, true);
3601 : 1 : domain2 = {real_sort, real_sort};
3602 : 1 : Cvc5Term trans22 = cvc5_declare_fun(
3603 : 1 : slv, "trans", domain2.size(), domain2.data(), bool_sort, true);
3604 : 1 : domain2 = {real_sort};
3605 : 1 : Cvc5Term post22 = cvc5_declare_fun(
3606 : 1 : slv, "post", domain2.size(), domain2.data(), bool_sort, true);
3607 : 1 : cvc5_add_sygus_inv_constraint(slv, inv22, pre22, trans22, post22);
3608 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3609 : : cvc5_add_sygus_inv_constraint(slv, inv, pre22, trans22, post22),
3610 : : "term is not associated with the term manager of this solver");
3611 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3612 : : cvc5_add_sygus_inv_constraint(slv, inv22, pre, trans22, post22),
3613 : : "term is not associated with the term manager of this solver");
3614 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3615 : : cvc5_add_sygus_inv_constraint(slv, inv22, pre22, trans, post22),
3616 : : "term is not associated with the term manager of this solver");
3617 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3618 : : cvc5_add_sygus_inv_constraint(slv, inv22, pre22, trans22, post),
3619 : : "term is not associated with the term manager of this solver");
3620 : 1 : cvc5_delete(slv);
3621 : 1 : cvc5_term_manager_release(tm);
3622 : 1 : cvc5_term_manager_delete(tm);
3623 [ + - ]: 1 : }
3624 : :
3625 : 4 : TEST_F(TestCApiBlackSolver, check_synth)
3626 : : {
3627 : : // requires option to be set
3628 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_synth(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
3629 : : "cannot check for a synthesis solution");
3630 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3631 : 1 : cvc5_check_synth(d_solver);
3632 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_synth(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3633 : : }
3634 : :
3635 : 4 : TEST_F(TestCApiBlackSolver, get_synth_solution)
3636 : : {
3637 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3638 : 1 : cvc5_set_option(d_solver, "incremental", "false");
3639 : :
3640 : 1 : Cvc5Term x = cvc5_mk_false(d_tm);
3641 : 1 : Cvc5Term f = cvc5_synth_fun(d_solver, "f", 0, nullptr, d_bool);
3642 : :
3643 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_synth_solution(d_solver, f), "not in a state");
[ - + ][ + - ]
[ + - ][ + - ]
3644 : :
3645 : 1 : Cvc5SynthResult res = cvc5_check_synth(d_solver);
3646 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_synth_result_has_solution(res));
3647 : :
3648 : 1 : cvc5_get_synth_solution(d_solver, f);
3649 : 1 : cvc5_get_synth_solution(d_solver, f);
3650 : :
3651 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_synth_solution(nullptr, f),
[ - + ][ + - ]
[ + - ][ + - ]
3652 : : "unexpected NULL argument");
3653 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_synth_solution(d_solver, nullptr), "invalid term");
[ - + ][ + - ]
[ + - ][ + - ]
3654 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_synth_solution(d_solver, x),
[ - + ][ + - ]
[ + - ][ + - ]
3655 : : "synthesis solution not found for given term");
3656 : :
3657 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3658 : 1 : Cvc5* slv = cvc5_new(tm);
3659 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3660 : : cvc5_get_synth_solution(slv, f),
3661 : : "term is not associated with the term manager of this solver");
3662 : 1 : cvc5_delete(slv);
3663 : 1 : cvc5_term_manager_release(tm);
3664 : 1 : cvc5_term_manager_delete(tm);
3665 : : }
3666 : :
3667 : 4 : TEST_F(TestCApiBlackSolver, get_synth_solutions)
3668 : : {
3669 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3670 : 1 : cvc5_set_option(d_solver, "incremental", "false");
3671 : :
3672 : 1 : Cvc5Term x = cvc5_mk_false(d_tm);
3673 : 1 : Cvc5Term f = cvc5_synth_fun(d_solver, "f", 0, nullptr, d_bool);
3674 : :
3675 : 1 : std::vector<Cvc5Term> args{f};
3676 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3677 : : cvc5_get_synth_solutions(d_solver, args.size(), args.data()),
3678 : : "not in a state");
3679 : :
3680 : 1 : cvc5_check_synth(d_solver);
3681 : :
3682 : 1 : cvc5_get_synth_solutions(d_solver, args.size(), args.data());
3683 : 1 : args = {f, f};
3684 : 1 : cvc5_get_synth_solutions(d_solver, args.size(), args.data());
3685 : :
3686 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_synth_solutions(d_solver, 0, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
3687 : : "unexpected NULL argument");
3688 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_synth_solutions(nullptr, args.size(), args.data()),
[ - + ][ + - ]
[ + - ][ + - ]
3689 : : "unexpected NULL argument");
3690 : 1 : args = {nullptr};
3691 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3692 : : cvc5_get_synth_solutions(d_solver, args.size(), args.data()),
3693 : : "invalid term at index 0");
3694 : 1 : args = {x};
3695 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3696 : : cvc5_get_synth_solutions(d_solver, args.size(), args.data()),
3697 : : "synthesis solution not found for term at index 0");
3698 : :
3699 : 1 : Cvc5TermManager* tm = cvc5_term_manager_new();
3700 : 1 : Cvc5* slv = cvc5_new(tm);
3701 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3702 : : cvc5_get_synth_solutions(slv, args.size(), args.data()),
3703 : : "expected a term associated with the term manager of this solver");
3704 : 1 : cvc5_delete(slv);
3705 : 1 : cvc5_term_manager_release(tm);
3706 : 1 : cvc5_term_manager_delete(tm);
3707 [ + - ]: 1 : }
3708 : :
3709 : 4 : TEST_F(TestCApiBlackSolver, check_synth_next)
3710 : : {
3711 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3712 : 1 : cvc5_set_option(d_solver, "incremental", "true");
3713 : :
3714 : 1 : Cvc5Term f = cvc5_synth_fun(d_solver, "f", 0, nullptr, d_bool);
3715 : :
3716 : 1 : Cvc5SynthResult res = cvc5_check_synth(d_solver);
3717 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_synth_result_has_solution(res));
3718 : :
3719 : 1 : std::vector<Cvc5Term> args{f};
3720 : 1 : cvc5_get_synth_solutions(d_solver, args.size(), args.data());
3721 : :
3722 : 1 : res = cvc5_check_synth_next(d_solver);
3723 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_synth_result_has_solution(res));
3724 : 1 : cvc5_get_synth_solutions(d_solver, args.size(), args.data());
3725 : :
3726 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_synth_next(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3727 : : }
3728 : :
3729 : 4 : TEST_F(TestCApiBlackSolver, check_synth_next2)
3730 : : {
3731 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3732 : 1 : cvc5_set_option(d_solver, "incremental", "false");
3733 : 1 : (void)cvc5_synth_fun(d_solver, "f", 0, nullptr, d_bool);
3734 : 1 : cvc5_check_synth(d_solver);
3735 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_synth_next(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
3736 : : "cannot check for a next synthesis solution");
3737 : : }
3738 : :
3739 : 4 : TEST_F(TestCApiBlackSolver, check_synth_next3)
3740 : : {
3741 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3742 : 1 : cvc5_set_option(d_solver, "incremental", "true");
3743 : 1 : (void)cvc5_synth_fun(d_solver, "f", 0, nullptr, d_bool);
3744 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_check_synth_next(d_solver),
[ - + ][ + - ]
[ + - ][ + - ]
3745 : : "unless immediately preceded");
3746 : : }
3747 : :
3748 : 4 : TEST_F(TestCApiBlackSolver, find_synth)
3749 : : {
3750 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3751 : 1 : Cvc5Term start = cvc5_mk_var(d_tm, d_bool, "start");
3752 : 1 : std::vector<Cvc5Term> symbols = {start};
3753 : : Cvc5Grammar g =
3754 : 1 : cvc5_mk_grammar(d_solver, 0, nullptr, symbols.size(), symbols.data());
3755 : :
3756 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3757 : : cvc5_synth_fun_with_grammar(d_solver, "f", 0, nullptr, d_bool, g),
3758 : : "invalid grammar");
3759 : :
3760 : 1 : Cvc5Term ttrue = cvc5_mk_true(d_tm);
3761 : 1 : Cvc5Term tfalse = cvc5_mk_false(d_tm);
3762 : 1 : cvc5_grammar_add_rule(g, start, ttrue);
3763 : 1 : cvc5_grammar_add_rule(g, start, tfalse);
3764 : 1 : (void)cvc5_synth_fun_with_grammar(d_solver, "f", 0, nullptr, d_bool, g);
3765 : :
3766 : : // should enumerate based on the grammar of the function to synthesize above
3767 : 1 : Cvc5Term t = cvc5_find_synth(d_solver, CVC5_FIND_SYNTH_TARGET_ENUM);
3768 [ + - ][ + - ]: 1 : ASSERT_TRUE(t && cvc5_sort_is_boolean(cvc5_term_get_sort(t)));
[ - + ][ + - ]
3769 : :
3770 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_find_synth(nullptr, CVC5_FIND_SYNTH_TARGET_ENUM),
[ - + ][ + - ]
[ + - ][ + - ]
3771 : : "unexpected NULL argument");
3772 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3773 : : cvc5_find_synth(d_solver, static_cast<Cvc5FindSynthTarget>(125)),
3774 : : "invalid find synthesis target");
3775 : :
3776 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
3777 : : cvc5_find_synth_with_grammar(nullptr, CVC5_FIND_SYNTH_TARGET_ENUM, g),
3778 : : "unexpected NULL argument");
3779 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_find_synth_with_grammar(
[ - + ][ + - ]
[ + - ][ + - ]
3780 : : d_solver, static_cast<Cvc5FindSynthTarget>(125), g),
3781 : : "invalid find synthesis target");
3782 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_find_synth_with_grammar(
[ - + ][ + - ]
[ + - ][ + - ]
3783 : : d_solver, CVC5_FIND_SYNTH_TARGET_ENUM, nullptr),
3784 : : "invalid grammar");
3785 [ + - ]: 1 : }
3786 : :
3787 : 4 : TEST_F(TestCApiBlackSolver, find_synth2)
3788 : : {
3789 : 1 : cvc5_set_option(d_solver, "sygus", "true");
3790 : 1 : cvc5_set_option(d_solver, "incremental", "true");
3791 : :
3792 : 1 : Cvc5Term start = cvc5_mk_var(d_tm, d_bool, "start");
3793 : 1 : std::vector<Cvc5Term> symbols = {start};
3794 : : Cvc5Grammar g =
3795 : 1 : cvc5_mk_grammar(d_solver, 0, nullptr, symbols.size(), symbols.data());
3796 : 1 : Cvc5Term ttrue = cvc5_mk_true(d_tm);
3797 : 1 : Cvc5Term tfalse = cvc5_mk_false(d_tm);
3798 : 1 : cvc5_grammar_add_rule(g, start, ttrue);
3799 : 1 : cvc5_grammar_add_rule(g, start, tfalse);
3800 : :
3801 : : // should enumerate true/false
3802 : : Cvc5Term t =
3803 : 1 : cvc5_find_synth_with_grammar(d_solver, CVC5_FIND_SYNTH_TARGET_ENUM, g);
3804 [ + - ][ + - ]: 1 : ASSERT_TRUE(t && cvc5_sort_is_boolean(cvc5_term_get_sort(t)));
[ - + ][ + - ]
3805 : 1 : t = cvc5_find_synth_next(d_solver);
3806 [ + - ][ + - ]: 1 : ASSERT_TRUE(t && cvc5_sort_is_boolean(cvc5_term_get_sort(t)));
[ - + ][ + - ]
3807 : :
3808 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_find_synth_next(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3809 [ + - ]: 1 : }
3810 : :
3811 : 4 : TEST_F(TestCApiBlackSolver, get_statistics)
3812 : : {
3813 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_statistics(nullptr), "unexpected NULL argument");
[ - + ][ + - ]
[ + - ][ + - ]
3814 : :
3815 : : // do some reasoning to make sure we have statistics
3816 : : {
3817 : 1 : Cvc5Sort s2 = cvc5_mk_array_sort(d_tm, d_int, d_int);
3818 : 1 : Cvc5Term t1 = cvc5_mk_const(d_tm, d_int, "i");
3819 : 1 : Cvc5Term t2 = cvc5_mk_const(d_tm, s2, "a");
3820 : 1 : std::vector<Cvc5Term> args = {t2, t1};
3821 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_SELECT, args.size(), args.data()), t1};
3822 : 1 : cvc5_assert_formula(
3823 : : d_solver,
3824 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_DISTINCT, args.size(), args.data()));
3825 : 1 : cvc5_check_sat(d_solver);
3826 : 1 : }
3827 : 1 : Cvc5Statistics stats = cvc5_get_statistics(d_solver);
3828 : 1 : (void)cvc5_stats_to_string(stats);
3829 : :
3830 : 1 : Cvc5Stat stat1 = cvc5_stats_get(stats, "global::totalTime");
3831 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_stat_is_internal(stat1));
3832 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_stat_is_default(stat1));
3833 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_stat_is_string(stat1));
3834 : 1 : (void)cvc5_stat_to_string(stat1);
3835 : :
3836 : 1 : std::string time = cvc5_stat_get_string(stat1);
3837 [ - + ][ + - ]: 1 : ASSERT_TRUE(time.rfind("ms") == time.size() - 2); // ends with "ms"
3838 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_stat_is_double(stat1));
3839 : :
3840 : 1 : Cvc5Stat stat2 = cvc5_stats_get(stats, "resource::resourceUnitsUsed");
3841 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_stat_is_internal(stat2));
3842 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_stat_is_default(stat2));
3843 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_stat_is_int(stat2));
3844 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_stat_get_int(stat2) >= 0);
3845 : 1 : (void)cvc5_stat_to_string(stat2);
3846 : :
3847 : 1 : cvc5_stats_iter_init(stats, true, true);
3848 : 1 : bool hasstats = false;
3849 [ + + ]: 522 : while (cvc5_stats_iter_has_next(stats))
3850 : : {
3851 : 521 : hasstats = true;
3852 : : const char* name;
3853 : 521 : Cvc5Stat stat = cvc5_stats_iter_next(stats, &name);
3854 : 521 : (void)cvc5_stat_to_string(stat);
3855 [ + + ]: 521 : if (name == std::string("theory::arrays::avgIndexListLength"))
3856 : : {
3857 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_stat_is_internal(stat));
3858 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_stat_is_double(stat));
3859 [ - + ][ + - ]: 1 : ASSERT_TRUE(std::isnan(cvc5_stat_get_double(stat)));
3860 : : }
3861 : : }
3862 [ - + ][ + - ]: 1 : ASSERT_TRUE(hasstats);
3863 : : }
3864 : :
3865 : 4 : TEST_F(TestCApiBlackSolver, print_statistics_safe)
3866 : : {
3867 : 1 : testing::internal::CaptureStdout();
3868 : 1 : cvc5_print_stats_safe(d_solver, STDOUT_FILENO);
3869 : 1 : testing::internal::GetCapturedStdout();
3870 : 1 : }
3871 : :
3872 : : namespace {
3873 : 2 : const Cvc5Term* plugin_unsat_check(size_t* size, void* state)
3874 : : {
3875 [ + + ]: 2 : static thread_local std::vector<Cvc5Term> lemmas;
3876 : : // add the "false" lemma.
3877 : 2 : Cvc5Term flem = cvc5_mk_false(static_cast<Cvc5TermManager*>(state));
3878 : 2 : lemmas = {flem};
3879 : 2 : *size = lemmas.size();
3880 : 2 : return lemmas.data();
3881 : : }
3882 : 3 : const char* plugin_unsat_get_name() { return "PluginUnsat"; }
3883 : : } // namespace
3884 : :
3885 : 4 : TEST_F(TestCApiBlackSolver, plugin_unsat)
3886 : : {
3887 : 1 : cvc5_set_option(d_solver, "sat-solver", "minisat");
3888 : 1 : Cvc5Plugin plugin{&plugin_unsat_check,
3889 : : nullptr,
3890 : : nullptr,
3891 : : &plugin_unsat_get_name,
3892 : 1 : d_tm,
3893 : : nullptr,
3894 : 1 : nullptr};
3895 : 1 : cvc5_add_plugin(d_solver, &plugin);
3896 [ - + ][ + - ]: 1 : ASSERT_TRUE(plugin.get_name() == std::string("PluginUnsat"));
3897 : : // should be unsat since the plugin above asserts "false" as a lemma
3898 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
3899 : : }
3900 : :
3901 : : namespace {
3902 : 1 : const Cvc5Term* plugin_count_check(size_t* size, void* state)
3903 : : {
3904 [ + - ]: 1 : static thread_local std::vector<Cvc5Term> lemmas;
3905 : 1 : ++*static_cast<size_t*>(state);
3906 : 1 : *size = lemmas.size();
3907 : 1 : return lemmas.data();
3908 : : }
3909 : 1 : const char* plugin_count_get_name() { return "PluginCount"; }
3910 : : } // namespace
3911 : :
3912 : 4 : TEST_F(TestCApiBlackSolver, plugin_multiple)
3913 : : {
3914 : 1 : cvc5_set_option(d_solver, "sat-solver", "minisat");
3915 : 1 : size_t num_checks = 0;
3916 : 1 : Cvc5Plugin plugin_unsat{&plugin_unsat_check,
3917 : : nullptr,
3918 : : nullptr,
3919 : : &plugin_unsat_get_name,
3920 : 1 : d_tm,
3921 : : nullptr,
3922 : 1 : nullptr};
3923 : 1 : Cvc5Plugin plugin_count{&plugin_count_check,
3924 : : nullptr,
3925 : : nullptr,
3926 : : &plugin_count_get_name,
3927 : : &num_checks,
3928 : : nullptr,
3929 : 1 : nullptr};
3930 : : // adding a second plugin must not invalidate the first one
3931 : 1 : cvc5_add_plugin(d_solver, &plugin_unsat);
3932 : 1 : cvc5_add_plugin(d_solver, &plugin_count);
3933 : : // should be unsat since the first plugin asserts "false" as a lemma
3934 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_unsat(cvc5_check_sat(d_solver)));
3935 [ - + ][ + - ]: 1 : ASSERT_GT(num_checks, 0);
3936 : : }
3937 : :
3938 : : namespace {
3939 : 2 : const Cvc5Term* plugin_null_check(size_t* size, void* state)
3940 : : {
3941 : : // no lemmas, return NULL instead of an array
3942 : 2 : ++*static_cast<size_t*>(state);
3943 : 2 : *size = 0;
3944 : 2 : return nullptr;
3945 : : }
3946 : 1 : const char* plugin_null_get_name() { return "PluginNull"; }
3947 : : } // namespace
3948 : :
3949 : 4 : TEST_F(TestCApiBlackSolver, plugin_null)
3950 : : {
3951 : 1 : cvc5_set_option(d_solver, "sat-solver", "minisat");
3952 : 1 : size_t num_checks = 0;
3953 : 1 : Cvc5Plugin plugin{&plugin_null_check,
3954 : : nullptr,
3955 : : nullptr,
3956 : : &plugin_null_get_name,
3957 : : &num_checks,
3958 : : nullptr,
3959 : 1 : nullptr};
3960 : 1 : cvc5_add_plugin(d_solver, &plugin);
3961 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, cvc5_get_boolean_sort(d_tm), "x");
3962 : 1 : cvc5_assert_formula(d_solver, x);
3963 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
3964 [ - + ][ + - ]: 1 : ASSERT_GT(num_checks, 0);
3965 : : }
3966 : :
3967 : : namespace {
3968 : 3 : void plugin_listen_notify_sat_clause(const Cvc5Term, void* state)
3969 : : {
3970 : 3 : *static_cast<bool*>(state) = true;
3971 : 3 : }
3972 : 4 : void plugin_listen_notify_theory_lemma(const Cvc5Term, void* state)
3973 : : {
3974 : 4 : *static_cast<bool*>(state) = true;
3975 : 4 : }
3976 : 1 : const char* plugin_listen_get_name() { return "PluginListen"; }
3977 : : } // namespace
3978 : :
3979 : 4 : TEST_F(TestCApiBlackSolver, plugin_listen)
3980 : : {
3981 : 1 : bool clause_seen = false;
3982 : 1 : bool lemma_seen = false;
3983 : 1 : Cvc5Plugin plugin{nullptr,
3984 : : &plugin_listen_notify_sat_clause,
3985 : : &plugin_listen_notify_theory_lemma,
3986 : : &plugin_listen_get_name,
3987 : : nullptr,
3988 : : &clause_seen,
3989 : 1 : &lemma_seen};
3990 : :
3991 : 1 : cvc5_set_option(d_solver, "sat-solver", "minisat");
3992 : : // Allow notifications for unit clauses added before the main solve.
3993 : 1 : cvc5_set_option(d_solver, "plugin-notify-sat-clause-in-solve", "false");
3994 : 1 : cvc5_add_plugin(d_solver, &plugin);
3995 : 1 : Cvc5Sort string_sort = cvc5_get_string_sort(d_tm);
3996 : 1 : Cvc5Term x = cvc5_mk_const(d_tm, string_sort, "x");
3997 : 1 : Cvc5Term y = cvc5_mk_const(d_tm, string_sort, "y");
3998 : 1 : std::vector<Cvc5Term> args{x, y};
3999 : : Cvc5Term ctn1 =
4000 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_STRING_CONTAINS, args.size(), args.data());
4001 : 1 : args = {y, x};
4002 : : Cvc5Term ctn2 =
4003 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_STRING_CONTAINS, args.size(), args.data());
4004 : 1 : args = {ctn1, ctn2};
4005 : 1 : cvc5_assert_formula(
4006 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
4007 : 1 : args = {x};
4008 : : Cvc5Term lx =
4009 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_STRING_LENGTH, args.size(), args.data());
4010 : 1 : args = {y};
4011 : : Cvc5Term ly =
4012 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_STRING_LENGTH, args.size(), args.data());
4013 : 1 : args = {lx, ly};
4014 : 1 : Cvc5Term lc = cvc5_mk_term(d_tm, CVC5_KIND_GT, args.size(), args.data());
4015 : 1 : cvc5_assert_formula(d_solver, lc);
4016 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
4017 : : // above input formulas should induce a theory lemma and SAT clause learning
4018 [ - + ][ + - ]: 1 : ASSERT_TRUE(lemma_seen);
4019 [ - + ][ + - ]: 1 : ASSERT_TRUE(clause_seen);
4020 [ + - ]: 1 : }
4021 : :
4022 : 4 : TEST_F(TestCApiBlackSolver, tuple_project)
4023 : : {
4024 : 1 : std::vector<Cvc5Term> args = {cvc5_mk_string(d_tm, "Z", false)};
4025 : : std::vector<Cvc5Term> elements = {
4026 : 1 : cvc5_mk_true(d_tm),
4027 : 2 : cvc5_mk_integer_int64(d_tm, 3),
4028 : 2 : cvc5_mk_string(d_tm, "C", false),
4029 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_SET_SINGLETON, args.size(), args.data())};
4030 : :
4031 : 1 : Cvc5Term tuple = cvc5_mk_tuple(d_tm, elements.size(), elements.data());
4032 : :
4033 : 1 : std::vector<uint32_t> indices1 = {};
4034 : 1 : std::vector<uint32_t> indices2 = {0};
4035 : 1 : std::vector<uint32_t> indices3 = {0, 1};
4036 : 1 : std::vector<uint32_t> indices4 = {0, 0, 2, 2, 3, 3, 0};
4037 : 1 : std::vector<uint32_t> indices5 = {4};
4038 : 1 : std::vector<uint32_t> indices6 = {0, 4};
4039 : :
4040 : 1 : args = {tuple};
4041 : 2 : (void)cvc5_mk_term_from_op(
4042 : : d_tm,
4043 : : cvc5_mk_op(
4044 : 1 : d_tm, CVC5_KIND_TUPLE_PROJECT, indices1.size(), indices1.data()),
4045 : : args.size(),
4046 : 1 : args.data());
4047 : 2 : (void)cvc5_mk_term_from_op(
4048 : : d_tm,
4049 : : cvc5_mk_op(
4050 : 1 : d_tm, CVC5_KIND_TUPLE_PROJECT, indices2.size(), indices2.data()),
4051 : : args.size(),
4052 : 1 : args.data());
4053 : 2 : (void)cvc5_mk_term_from_op(
4054 : : d_tm,
4055 : : cvc5_mk_op(
4056 : 1 : d_tm, CVC5_KIND_TUPLE_PROJECT, indices3.size(), indices3.data()),
4057 : : args.size(),
4058 : 1 : args.data());
4059 : 2 : (void)cvc5_mk_term_from_op(
4060 : : d_tm,
4061 : : cvc5_mk_op(
4062 : 1 : d_tm, CVC5_KIND_TUPLE_PROJECT, indices4.size(), indices4.data()),
4063 : : args.size(),
4064 : 1 : args.data());
4065 : :
4066 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
4067 : : cvc5_mk_term_from_op(
4068 : : d_tm,
4069 : : cvc5_mk_op(
4070 : : d_tm, CVC5_KIND_TUPLE_PROJECT, indices5.size(), indices5.data()),
4071 : : args.size(),
4072 : : args.data()),
4073 : : "Project index 4");
4074 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(
[ - + ][ + - ]
[ + - ][ + - ]
4075 : : cvc5_mk_term_from_op(
4076 : : d_tm,
4077 : : cvc5_mk_op(
4078 : : d_tm, CVC5_KIND_TUPLE_PROJECT, indices6.size(), indices6.data()),
4079 : : args.size(),
4080 : : args.data()),
4081 : : "Project index 4");
4082 : :
4083 : 1 : std::vector<uint32_t> indices = {0, 3, 2, 0, 1, 2};
4084 : :
4085 : : Cvc5Op op =
4086 : 1 : cvc5_mk_op(d_tm, CVC5_KIND_TUPLE_PROJECT, indices.size(), indices.data());
4087 : : Cvc5Term projection =
4088 : 1 : cvc5_mk_term_from_op(d_tm, op, args.size(), args.data());
4089 : :
4090 : 1 : Cvc5Datatype datatype = cvc5_sort_get_datatype(cvc5_term_get_sort(tuple));
4091 : 1 : Cvc5DatatypeConstructor cons = cvc5_dt_get_constructor(datatype, 0);
4092 : :
4093 [ + + ]: 7 : for (size_t i = 0; i < indices.size(); i++)
4094 : : {
4095 : 6 : args = {cvc5_dt_sel_get_term(cvc5_dt_cons_get_selector(cons, indices[i])),
4096 : 6 : tuple};
4097 : : Cvc5Term selected =
4098 : 6 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_SELECTOR, args.size(), args.data());
4099 : 6 : Cvc5Term simplified = cvc5_simplify(d_solver, selected, false);
4100 [ - + ][ + - ]: 6 : ASSERT_TRUE(cvc5_term_is_equal(elements[indices[i]], simplified));
4101 : : }
4102 : :
4103 [ - + ]: 2 : ASSERT_EQ(
4104 : : std::string(
4105 : : "((_ tuple.project 0 3 2 0 1 2) (tuple true 3 \"C\" (set.singleton "
4106 : : "\"Z\")))"),
4107 [ + - ]: 1 : cvc5_term_to_string(projection));
4108 [ + - ][ + - ]: 1 : }
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
4109 : :
4110 : 4 : TEST_F(TestCApiBlackSolver, vertical_bars)
4111 : : {
4112 : 1 : Cvc5Term a = cvc5_declare_fun(d_solver, "|a |", 0, nullptr, d_real, true);
4113 [ - + ][ + - ]: 2 : ASSERT_EQ(std::string("|a |"), cvc5_term_to_string(a));
4114 : : }
4115 : :
4116 : 4 : TEST_F(TestCApiBlackSolver, get_version)
4117 : : {
4118 : 1 : std::cout << cvc5_get_version(d_solver) << std::endl;
4119 : 1 : }
4120 : :
4121 : 4 : TEST_F(TestCApiBlackSolver, multiple_solvers)
4122 : : {
4123 : : Cvc5Term zero, value1, value2;
4124 : : Cvc5Term deffun;
4125 : : {
4126 : 1 : Cvc5* s1 = cvc5_new(d_tm);
4127 : 1 : cvc5_set_logic(s1, "ALL");
4128 : 1 : cvc5_set_option(s1, "produce-models", "true");
4129 : 1 : Cvc5Term fun1 = cvc5_declare_fun(s1, "f1", 0, nullptr, d_int, true);
4130 : 1 : Cvc5Term x = cvc5_mk_var(d_tm, d_int, "x");
4131 : 1 : zero = cvc5_mk_integer_int64(d_tm, 0);
4132 : 1 : std::vector<Cvc5Term> args = {x};
4133 : : deffun =
4134 : 1 : cvc5_define_fun(s1, "f", args.size(), args.data(), d_int, zero, true);
4135 : 1 : args = {fun1, zero};
4136 : 1 : cvc5_assert_formula(
4137 : 1 : s1, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
4138 : 1 : cvc5_check_sat(s1);
4139 : 1 : value1 = cvc5_get_value(s1, fun1);
4140 : 1 : cvc5_delete(s1);
4141 : 1 : }
4142 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(zero, value1));
4143 : : {
4144 : 1 : Cvc5* s2 = cvc5_new(d_tm);
4145 : 1 : cvc5_set_logic(s2, "ALL");
4146 : 1 : cvc5_set_option(s2, "produce-models", "true");
4147 : 1 : Cvc5Term fun2 = cvc5_declare_fun(s2, "f2", 0, nullptr, d_int, true);
4148 : 1 : std::vector<Cvc5Term> args = {fun2, value1};
4149 : 1 : cvc5_assert_formula(
4150 : 1 : s2, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
4151 : 1 : cvc5_check_sat(s2);
4152 : 1 : value2 = cvc5_get_value(s2, fun2);
4153 : 1 : cvc5_delete(s2);
4154 : 1 : }
4155 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(value1, value2));
4156 : : {
4157 : 1 : Cvc5* s3 = cvc5_new(d_tm);
4158 : 1 : cvc5_set_logic(s3, "ALL");
4159 : 1 : cvc5_set_option(s3, "produce-models", "true");
4160 : 1 : Cvc5Term fun3 = cvc5_declare_fun(s3, "f3", 0, nullptr, d_int, true);
4161 : 1 : std::vector<Cvc5Term> args = {deffun, zero};
4162 : : Cvc5Term apply =
4163 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data());
4164 : 1 : args = {fun3, apply};
4165 : 1 : cvc5_assert_formula(
4166 : 1 : s3, cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data()));
4167 : 1 : cvc5_check_sat(s3);
4168 : 1 : Cvc5Term value3 = cvc5_get_value(s3, fun3);
4169 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_term_is_equal(value1, value3));
4170 : 1 : cvc5_delete(s3);
4171 [ + - ]: 1 : }
4172 : : }
4173 : :
4174 : : #ifdef CVC5_USE_COCOA
4175 : :
4176 : 4 : TEST_F(TestCApiBlackSolver, basic_finite_field)
4177 : : {
4178 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
4179 : :
4180 : 1 : Cvc5Sort ff_sort = cvc5_mk_ff_sort(d_tm, "5", 10);
4181 : 1 : Cvc5Term a = cvc5_mk_const(d_tm, ff_sort, "a");
4182 : 1 : Cvc5Term b = cvc5_mk_const(d_tm, ff_sort, "b");
4183 [ - + ][ + - ]: 2 : ASSERT_EQ(std::string("5"), cvc5_sort_ff_get_size(ff_sort));
4184 : :
4185 : 1 : std::vector<Cvc5Term> args = {a, b};
4186 : 0 : args = {
4187 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_FINITE_FIELD_MULT, args.size(), args.data()),
4188 : 1 : cvc5_mk_ff_elem(d_tm, "1", ff_sort, 10)};
4189 : 1 : Cvc5Term inv = cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
4190 : 1 : args = {a, cvc5_mk_ff_elem(d_tm, "2", ff_sort, 10)};
4191 : : Cvc5Term a_is_two =
4192 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
4193 : :
4194 : 1 : cvc5_assert_formula(d_solver, inv);
4195 : 1 : cvc5_assert_formula(d_solver, a_is_two);
4196 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
4197 [ - + ]: 1 : ASSERT_EQ(cvc5_term_get_ff_value(cvc5_get_value(d_solver, a)),
4198 [ + - ]: 1 : std::string("2"));
4199 [ - + ]: 1 : ASSERT_EQ(cvc5_term_get_ff_value(cvc5_get_value(d_solver, b)),
4200 [ + - ]: 1 : std::string("-2"));
4201 : :
4202 : 1 : args = {b, cvc5_mk_ff_elem(d_tm, "2", ff_sort, 10)};
4203 : : Cvc5Term b_is_two =
4204 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
4205 : 1 : cvc5_assert_formula(d_solver, b_is_two);
4206 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
4207 : : }
4208 : :
4209 : 4 : TEST_F(TestCApiBlackSolver, basic_finite_field_base)
4210 : : {
4211 : 1 : cvc5_set_option(d_solver, "produce-models", "true");
4212 : :
4213 : 1 : Cvc5Sort ff_sort = cvc5_mk_ff_sort(d_tm, "101", 2);
4214 : 1 : Cvc5Term a = cvc5_mk_const(d_tm, ff_sort, "a");
4215 : 1 : Cvc5Term b = cvc5_mk_const(d_tm, ff_sort, "b");
4216 [ - + ][ + - ]: 2 : ASSERT_EQ(std::string("5"), cvc5_sort_ff_get_size(ff_sort));
4217 : :
4218 : 1 : std::vector<Cvc5Term> args = {a, b};
4219 : 0 : args = {
4220 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_FINITE_FIELD_MULT, args.size(), args.data()),
4221 : 1 : cvc5_mk_ff_elem(d_tm, "1", ff_sort, 3)};
4222 : 1 : Cvc5Term inv = cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
4223 : :
4224 : 1 : args = {a, cvc5_mk_ff_elem(d_tm, "10", ff_sort, 2)};
4225 : : Cvc5Term a_is_two =
4226 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
4227 : :
4228 : 1 : cvc5_assert_formula(d_solver, inv);
4229 : 1 : cvc5_assert_formula(d_solver, a_is_two);
4230 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
4231 [ - + ]: 1 : ASSERT_EQ(cvc5_term_get_ff_value(cvc5_get_value(d_solver, a)),
4232 [ + - ]: 1 : std::string("2"));
4233 [ - + ]: 1 : ASSERT_EQ(cvc5_term_get_ff_value(cvc5_get_value(d_solver, b)),
4234 [ + - ]: 1 : std::string("-2"));
4235 : :
4236 : 1 : args = {b, cvc5_mk_ff_elem(d_tm, "2", ff_sort, 10)};
4237 : : Cvc5Term b_is_two =
4238 : 1 : cvc5_mk_term(d_tm, CVC5_KIND_EQUAL, args.size(), args.data());
4239 : 1 : cvc5_assert_formula(d_solver, b_is_two);
4240 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_result_is_sat(cvc5_check_sat(d_solver)));
4241 : : }
4242 : : #endif // CVC5_USE_COCOA
4243 : :
4244 : 4 : TEST_F(TestCApiBlackSolver, output1)
4245 : : {
4246 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_is_output_on(nullptr, "inst"),
[ - + ][ + - ]
[ + - ][ + - ]
4247 : : "unexpected NULL argument");
4248 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_is_output_on(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
4249 : : "unexpected NULL argument");
4250 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_is_output_on(d_solver, "foo-invalid"),
[ - + ][ + - ]
[ + - ][ + - ]
4251 : : "invalid output tag");
4252 : :
4253 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_output(nullptr, "inst", "<stdout>"),
[ - + ][ + - ]
[ + - ][ + - ]
4254 : : "unexpected NULL argument");
4255 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_output(d_solver, nullptr, "<stdout>"),
[ - + ][ + - ]
[ + - ][ + - ]
4256 : : "unexpected NULL argument");
4257 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_output(d_solver, "inst", nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
4258 : : "unexpected NULL argument");
4259 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_get_output(d_solver, "foo-invalid", "<stdout>"),
[ - + ][ + - ]
[ + - ][ + - ]
4260 : : "invalid output tag");
4261 : :
4262 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_close_output(nullptr, "<stdout>"),
[ - + ][ + - ]
[ + - ][ + - ]
4263 : : "unexpected NULL argument");
4264 [ - + ][ + - ]: 5 : ASSERT_CVC5_ERROR(cvc5_close_output(d_solver, nullptr),
[ - + ][ + - ]
[ + - ][ + - ]
4265 : : "unexpected NULL argument");
4266 : : // should not fail
4267 : 1 : cvc5_close_output(d_solver, "<stdout>");
4268 : : }
4269 : :
4270 : 4 : TEST_F(TestCApiBlackSolver, output2)
4271 : : {
4272 [ - + ][ + - ]: 1 : ASSERT_FALSE(cvc5_is_output_on(d_solver, "inst"));
4273 : : // noop if output tag is not enabled
4274 : 1 : cvc5_get_output(d_solver, "inst", "<stdout>");
4275 : 1 : cvc5_set_option(d_solver, "output", "inst");
4276 [ - + ][ + - ]: 1 : ASSERT_TRUE(cvc5_is_output_on(d_solver, "inst"));
4277 : 1 : cvc5_get_output(d_solver, "inst", "<stdout>");
4278 : : }
4279 : :
4280 : 4 : TEST_F(TestCApiBlackSolver, output3)
4281 : : {
4282 : 1 : cvc5_set_option(d_solver, "output", "post-asserts");
4283 : 1 : cvc5_get_output(d_solver, "post-asserts", "<stdout>");
4284 : :
4285 : 1 : testing::internal::CaptureStdout();
4286 : :
4287 : 1 : std::vector<Cvc5Term> vars = {cvc5_mk_var(d_tm, d_bool, "b")};
4288 : 1 : Cvc5Term g = cvc5_define_fun(
4289 : 1 : d_solver, "g", vars.size(), vars.data(), d_bool, vars[0], true);
4290 : 1 : std::vector<Cvc5Term> args = {g, cvc5_mk_true(d_tm)};
4291 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data())};
4292 : 1 : Cvc5Term appnot = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
4293 : 1 : args = {cvc5_define_fun(
4294 : 1 : d_solver, "f", 0, nullptr, d_bool, cvc5_mk_true(d_tm), true)};
4295 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()), appnot};
4296 : 1 : cvc5_assert_formula(
4297 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
4298 : 1 : cvc5_check_sat(d_solver);
4299 : :
4300 : 1 : std::string out = testing::internal::GetCapturedStdout();
4301 : 1 : std::stringstream expected;
4302 : 1 : expected << ";; post-asserts start" << std::endl;
4303 : 1 : expected << "(set-logic ALL)" << std::endl;
4304 : 1 : expected << "(define-fun f () Bool true)" << std::endl;
4305 : 1 : expected << "(define-fun g ((b Bool)) Bool b)" << std::endl;
4306 : 1 : expected << "(assert false)" << std::endl;
4307 : 1 : expected << "(check-sat)" << std::endl;
4308 : 1 : expected << ";; post-asserts end" << std::endl;
4309 [ - + ][ + - ]: 2 : ASSERT_EQ(out, expected.str());
4310 [ + - ][ + - ]: 1 : }
[ + - ][ + - ]
4311 : :
4312 : 4 : TEST_F(TestCApiBlackSolver, output4)
4313 : : {
4314 : 1 : const char* filename = "foo.out";
4315 : 1 : cvc5_set_option(d_solver, "output", "post-asserts");
4316 : 1 : cvc5_get_output(d_solver, "post-asserts", filename);
4317 : :
4318 : 1 : std::vector<Cvc5Term> vars = {cvc5_mk_var(d_tm, d_bool, "b")};
4319 : 1 : Cvc5Term g = cvc5_define_fun(
4320 : 1 : d_solver, "g", vars.size(), vars.data(), d_bool, vars[0], true);
4321 : 1 : std::vector<Cvc5Term> args = {g, cvc5_mk_true(d_tm)};
4322 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_APPLY_UF, args.size(), args.data())};
4323 : 1 : Cvc5Term appnot = cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data());
4324 : 1 : args = {cvc5_define_fun(
4325 : 1 : d_solver, "f", 0, nullptr, d_bool, cvc5_mk_true(d_tm), true)};
4326 : 1 : args = {cvc5_mk_term(d_tm, CVC5_KIND_NOT, args.size(), args.data()), appnot};
4327 : 1 : cvc5_assert_formula(
4328 : 1 : d_solver, cvc5_mk_term(d_tm, CVC5_KIND_OR, args.size(), args.data()));
4329 : 1 : cvc5_check_sat(d_solver);
4330 : :
4331 : 1 : cvc5_close_output(d_solver, filename);
4332 : 1 : std::ifstream in(filename);
4333 : 1 : std::stringstream out;
4334 : 1 : out << in.rdbuf();
4335 : 1 : std::stringstream expected;
4336 : 1 : expected << ";; post-asserts start" << std::endl;
4337 : 1 : expected << "(set-logic ALL)" << std::endl;
4338 : 1 : expected << "(define-fun f () Bool true)" << std::endl;
4339 : 1 : expected << "(define-fun g ((b Bool)) Bool b)" << std::endl;
4340 : 1 : expected << "(assert false)" << std::endl;
4341 : 1 : expected << "(check-sat)" << std::endl;
4342 : 1 : expected << ";; post-asserts end" << std::endl;
4343 [ - + ][ + - ]: 2 : ASSERT_EQ(out.str(), expected.str());
4344 : 1 : std::remove(filename);
4345 [ + - ][ + - ]: 1 : }
[ + - ][ + - ]
[ + - ]
4346 : : } // namespace cvc5::internal::test
|
