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