Skip to content

Commit 70bf4f1

Browse files
calccryptocalccrypto
committed
rename get_str_callback to copy_columns_callback and reduce duplicate functionality
1 parent 36bb0ec commit 70bf4f1

File tree

4 files changed

+114
-109
lines changed

4 files changed

+114
-109
lines changed

‎include/dbutils.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -178,6 +178,8 @@ int stopdb(sqlite3 *db);
178178

179179
void closedb(sqlite3 *db);
180180

181+
int copy_columns_callback(void *args, int count, char **data, char **columns);
182+
181183
void insertdbfin(sqlite3_stmt *res);
182184

183185
sqlite3_stmt *insertdbprep(sqlite3 *db, const char *sqli);

‎src/dbutils.c

Lines changed: 31 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -403,6 +403,34 @@ void closedb(sqlite3 *db)
403403
sqlite3_close(db);
404404
}
405405

406+
int copy_columns_callback(void *args, int count, char **data, char **columns) {
407+
(void) columns;
408+
409+
/*
410+
* strs should have space for at least count columns
411+
*
412+
* make sure to initialize strs[i] to NULL or good values
413+
*/
414+
char **strs = (char **) args;
415+
416+
for(int i = 0; i < count; i++) {
417+
if (!data[i]) {
418+
continue;
419+
}
420+
421+
const size_t len = strlen(data[i]);
422+
423+
if (!strs[i]) {
424+
strs[i] = malloc(len + 1);
425+
}
426+
427+
SNFORMAT_S(strs[i], len + 1, 1,
428+
data[i], len);
429+
}
430+
431+
return 0;
432+
}
433+
406434
void insertdbfin(sqlite3_stmt *res)
407435
{
408436
sqlite3_finalize(res);
@@ -689,24 +717,6 @@ int insertsumdb(sqlite3 *sdb, const char *path, struct work *pwork, struct entry
689717
return 0;
690718
}
691719

692-
static int get_2_strs(void *args, int count, char **data, char **columns) {
693-
(void) count;
694-
(void) columns;
695-
696-
char **strs = (char **) args;
697-
698-
for(int i = 0; i < 2; i++) {
699-
const size_t len = strlen(data[i]) + 2; /* + 2 for quotation marks */
700-
strs[i] = malloc(len + 1);
701-
SNFORMAT_S(strs[i], len + 1, 3,
702-
"'", (size_t) 1,
703-
data[i], len - 2,
704-
"'", (size_t) 1);
705-
}
706-
707-
return 0;
708-
}
709-
710720
int inserttreesumdb(const char *name, sqlite3 *sdb, struct sum *su,int rectype,int uid,int gid)
711721
{
712722
int depth = 0;
@@ -718,7 +728,7 @@ int inserttreesumdb(const char *name, sqlite3 *sdb, struct sum *su,int rectype,i
718728

719729
char *ip[2] = {NULL, NULL};
720730
if (sqlite3_exec(sdb, "SELECT inode, pinode FROM " SUMMARY " WHERE isroot == 1;",
721-
get_2_strs, ip, &err) != SQLITE_OK) {
731+
copy_columns_callback, ip, &err) != SQLITE_OK) {
722732
fprintf(stderr, "Could not get inode from %s: %s\n", SUMMARY, err);
723733
sqlite3_free(err);
724734
return 1;
@@ -728,14 +738,14 @@ int inserttreesumdb(const char *name, sqlite3 *sdb, struct sum *su,int rectype,i
728738
char *pinode = ip[1];
729739

730740
char sqlstmt[MAXSQL];
731-
SNPRINTF(sqlstmt, MAXSQL, "INSERT INTO " TREESUMMARY " VALUES (%s, %s, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %d, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %d, %d, %d);",
741+
SNPRINTF(sqlstmt, MAXSQL, "INSERT INTO " TREESUMMARY " VALUES ('%s', '%s', %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %d, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %d, %d, %d);",
732742
inode, pinode, su->totsubdirs, su->maxsubdirfiles, su->maxsubdirlinks, su->maxsubdirsize, su->totfiles, su->totlinks, su->minuid, su->maxuid, su->mingid, su->maxgid, su->minsize, su->maxsize, su->totzero, su->totltk, su->totmtk, su->totltm, su->totmtm, su->totmtg, su->totmtt, su->totsize, su->minctime, su->maxctime, su->minmtime, su->maxmtime, su->minatime, su->maxatime, su->minblocks, su->maxblocks, su->totxattr, depth, su->mincrtime, su->maxcrtime, su->minossint1, su->maxossint1, su->totossint1, su->minossint2, su->maxossint2, su->totossint2, su->minossint3, su->maxossint3, su->totossint3, su->minossint4, su->maxossint4, su->totossint4, su->totextdbs, rectype, uid, gid);
733743

734744
free(pinode);
735745
free(inode);
736746

737747
err = NULL;
738-
if (sqlite3_exec(sdb, sqlstmt, 0, 0, &err) != SQLITE_OK ) {
748+
if (sqlite3_exec(sdb, sqlstmt, NULL, NULL, &err) != SQLITE_OK ) {
739749
fprintf(stderr, "SQL error on insert (treesummary): %s %s\n", err, sqlstmt);
740750
sqlite3_free(err);
741751
}

‎test/unit/googletest/dbutils.cpp.in

Lines changed: 65 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -72,14 +72,6 @@ OF SUCH DAMAGE.
7272

7373
#include "dbutils.h"
7474

75-
static int str_output(void *args, int, char **data, char **) {
76-
char *output = static_cast <char *> (args);
77-
const size_t len = strlen(data[0]);
78-
memcpy(output, data[0], len);
79-
output[len] = '\0';
80-
return 0;
81-
}
82-
8375
TEST(attachdb, nullptr) {
8476
EXPECT_EQ(attachdb("filename", nullptr, "attach name", SQLITE_OPEN_READONLY, 0), nullptr);
8577
EXPECT_EQ(attachdb("filename", nullptr, "attach name", SQLITE_OPEN_READONLY, 1), nullptr);
@@ -184,8 +176,9 @@ TEST(addqueryfuncs, path) {
184176
ASSERT_NE(db, nullptr);
185177
ASSERT_EQ(addqueryfuncs_with_context(db, &work), 0);
186178

187-
char output[MAXPATH] = {};
188-
EXPECT_EQ(sqlite3_exec(db, "SELECT path();", str_output, output, nullptr), SQLITE_OK);
179+
char buf[MAXPATH] = {};
180+
char *output = buf;
181+
EXPECT_EQ(sqlite3_exec(db, "SELECT path();", copy_columns_callback, &output, nullptr), SQLITE_OK);
189182

190183
EXPECT_STREQ(output, work.name);
191184

@@ -207,8 +200,9 @@ TEST(addqueryfuncs, epath) {
207200
ASSERT_NE(db, nullptr);
208201
ASSERT_EQ(addqueryfuncs_with_context(db, &work), 0);
209202

210-
char output[MAXPATH] = {};
211-
EXPECT_EQ(sqlite3_exec(db, "SELECT epath();", str_output, output, nullptr), SQLITE_OK);
203+
char buf[MAXPATH] = {};
204+
char *output = buf;
205+
EXPECT_EQ(sqlite3_exec(db, "SELECT epath();", copy_columns_callback, &output, nullptr), SQLITE_OK);
212206

213207
EXPECT_STREQ(output, dirname);
214208

@@ -224,7 +218,7 @@ TEST(addqueryfuncs, fpath) {
224218
ASSERT_EQ(sqlite3_open(":memory:", &db), SQLITE_OK);
225219
ASSERT_NE(db, nullptr);
226220
ASSERT_EQ(addqueryfuncs_with_context(db, &work), 0);
227-
EXPECT_EQ(sqlite3_exec(db, "SELECT fpath();", str_output, &work, nullptr), SQLITE_OK);
221+
EXPECT_EQ(sqlite3_exec(db, "SELECT fpath();", nullptr, nullptr, nullptr), SQLITE_OK);
228222
EXPECT_NE(work.fullpath, nullptr);
229223
EXPECT_GT(work.fullpath_len, (size_t) 0);
230224

@@ -233,7 +227,7 @@ TEST(addqueryfuncs, fpath) {
233227
const size_t fullpath_len = work.fullpath_len;
234228

235229
// call again - should not update fullpath
236-
EXPECT_EQ(sqlite3_exec(db, "SELECT fpath();", str_output, &work, nullptr), SQLITE_OK);
230+
EXPECT_EQ(sqlite3_exec(db, "SELECT fpath();", nullptr, nullptr, nullptr), SQLITE_OK);
237231
EXPECT_EQ(work.fullpath, fullpath);
238232
EXPECT_EQ(work.fullpath_len, fullpath_len);
239233

@@ -264,8 +258,9 @@ TEST(addqueryfuncs, rpath) {
264258
SNPRINTF(query, MAXSQL, "SELECT rpath('%s', %d);", dirname, rollupscore);
265259

266260
// the path returned by the query is the path without the index prefix
267-
char output[MAXPATH] = {};
268-
EXPECT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
261+
char buf[MAXPATH] = {};
262+
char *output = buf;
263+
EXPECT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
269264

270265
EXPECT_STREQ(output, work.name);
271266
}
@@ -280,8 +275,8 @@ TEST(addqueryfuncs, uidtouser) {
280275
struct passwd pwd;
281276
struct passwd *result = nullptr;
282277

283-
char buf[MAXPATH] = {};
284-
ASSERT_EQ(getpwuid_r(uid, &pwd, buf, MAXPATH, &result), 0);
278+
char ubuf[MAXPATH] = {};
279+
ASSERT_EQ(getpwuid_r(uid, &pwd, ubuf, sizeof(ubuf), &result), 0);
285280
ASSERT_EQ(result, &pwd);
286281

287282
sqlite3 *db = nullptr;
@@ -294,8 +289,9 @@ TEST(addqueryfuncs, uidtouser) {
294289
char query[MAXSQL] = {};
295290
SNPRINTF(query, MAXSQL, "SELECT uidtouser('%d')", uid);
296291

297-
char output[MAXPATH] = {};
298-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
292+
char buf[MAXPATH] = {};
293+
char *output = buf;
294+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
299295

300296
EXPECT_STREQ(output, pwd.pw_name);
301297

@@ -309,8 +305,8 @@ TEST(addqueryfuncs, gidtogroup) {
309305
struct group grp;
310306
struct group *result = nullptr;
311307

312-
char buf[MAXPATH] = {};
313-
ASSERT_EQ(getgrgid_r(gid, &grp, buf, MAXPATH, &result), 0);
308+
char gbuf[MAXPATH] = {};
309+
ASSERT_EQ(getgrgid_r(gid, &grp, gbuf, sizeof(gbuf), &result), 0);
314310
ASSERT_EQ(result, &grp);
315311

316312
sqlite3 *db = nullptr;
@@ -323,8 +319,9 @@ TEST(addqueryfuncs, gidtogroup) {
323319
char query[MAXSQL] = {};
324320
SNPRINTF(query, MAXSQL, "SELECT gidtogroup('%d')", gid);
325321

326-
char output[MAXPATH] = {};
327-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
322+
char buf[MAXPATH] = {};
323+
char *output = buf;
324+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
328325

329326
EXPECT_STREQ(output, grp.gr_name);
330327

@@ -340,17 +337,18 @@ TEST(addqueryfuncs, modetotxt) {
340337

341338
for(mode_t perm = 0; perm < 01000; perm++) {
342339
char query[MAXSQL] = {};
343-
char output[11] = {};
340+
char buf[11] = {};
341+
char *output = buf;
344342
char expected[11] = {};
345343

346344
// file
347345
SNPRINTF(query, MAXSQL, "SELECT modetotxt(%zu)", (size_t) perm);
348-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
346+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
349347
EXPECT_STREQ(output, modetostr(expected, 11, perm));
350348

351349
// directory
352350
SNPRINTF(query, MAXSQL, "SELECT modetotxt(%zu)", perm | S_IFDIR);
353-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
351+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
354352
EXPECT_STREQ(output, modetostr(expected, 11, perm | S_IFDIR));
355353
}
356354

@@ -371,8 +369,9 @@ TEST(addqueryfuncs, strftime) {
371369
char query[MAXSQL] = {};
372370
SNPRINTF(query, MAXSQL, "SELECT strftime('%s', %d)", fmt, (int) now);
373371

374-
char output[MAXPATH] = {};
375-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
372+
char buf[MAXPATH] = {};
373+
char *output = buf;
374+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
376375

377376
char expected[MAXSQL] = {};
378377
struct tm tm;
@@ -421,37 +420,38 @@ TEST(addqueryfuncs, blocksize) {
421420

422421
for(size_t j = 0; j < 3; j++) {
423422
char query[MAXSQL] = {};
424-
char output[MAXPATH] = {};
423+
char buf[MAXPATH] = {};
424+
char *output = buf;
425425
char expected[MAXPATH] = {};
426426

427427
SNPRINTF(query, MAXSQL, "SELECT blocksize(%zu, '%c')", iBinputs[j], SIZE[i]);
428-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
428+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
429429
SNPRINTF(expected, MAXPATH, "%c%c", expecteds[j], SIZE[i]);
430430
EXPECT_STREQ(output, expected);
431431

432432
SNPRINTF(query, MAXSQL, "SELECT blocksize(%zu, '%cB')", Binputs[j], SIZE[i]);
433-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
433+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
434434
SNPRINTF(expected, MAXPATH, "%c%cB", expecteds[j], SIZE[i]);
435435
EXPECT_STREQ(output, expected);
436436

437437
SNPRINTF(query, MAXSQL, "SELECT blocksize(%zu, '%ciB')", iBinputs[j], SIZE[i]);
438-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
438+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
439439
SNPRINTF(expected, MAXPATH, "%c%ciB", expecteds[j], SIZE[i]);
440440
EXPECT_STREQ(output, expected);
441441
}
442442
}
443443

444-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize('', '')", str_output, nullptr, nullptr), SQLITE_ERROR); /* non-integer size argument */
445-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize('abc', '')", str_output, nullptr, nullptr), SQLITE_ERROR); /* missing size argument */
446-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'i')", str_output, nullptr, nullptr), SQLITE_ERROR); /* single bad character */
447-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'iB')", str_output, nullptr, nullptr), SQLITE_ERROR); /* 1st character isn't valid */
448-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'ij')", str_output, nullptr, nullptr), SQLITE_ERROR); /* 2nd character isn't B */
449-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'AiB')", str_output, nullptr, nullptr), SQLITE_ERROR); /* 1st character isn't valid */
450-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'AjB')", str_output, nullptr, nullptr), SQLITE_ERROR); /* 2nd character isn't i */
451-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'Aij')", str_output, nullptr, nullptr), SQLITE_ERROR); /* 3nd character isn't B */
452-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, '0KB')", str_output, nullptr, nullptr), SQLITE_ERROR); /* block coefficient is 0 */
453-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, '1.2KiB')", str_output, nullptr, nullptr), SQLITE_ERROR); /* decimal point is not allowed */
454-
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'KiBGiB')", str_output, nullptr, nullptr), SQLITE_ERROR); /* suffix is too long */
444+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize('', '')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* non-integer size argument */
445+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize('abc', '')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* missing size argument */
446+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'i')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* single bad character */
447+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'iB')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* 1st character isn't valid */
448+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'ij')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* 2nd character isn't B */
449+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'AiB')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* 1st character isn't valid */
450+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'AjB')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* 2nd character isn't i */
451+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'Aij')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* 3nd character isn't B */
452+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, '0KB')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* block coefficient is 0 */
453+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, '1.2KiB')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* decimal point is not allowed */
454+
ASSERT_EQ(sqlite3_exec(db, "SELECT blocksize(0, 'KiBGiB')", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* suffix is too long */
455455

456456
sqlite3_close(db);
457457
}
@@ -464,12 +464,13 @@ TEST(addqueryfuncs, human_readable_size) {
464464
ASSERT_EQ(addqueryfuncs(db), 0);
465465

466466
char query[MAXSQL] = {};
467-
char output[MAXPATH] = {};
467+
char buf[MAXPATH] = {};
468+
char *output = buf;
468469

469470
size_t size = 1;
470471

471472
SNPRINTF(query, MAXSQL, "SELECT human_readable_size(%zu);", size);
472-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
473+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
473474
EXPECT_STREQ(output, "1.0");
474475

475476
// greater than 1K - has unit suffix
@@ -479,13 +480,13 @@ TEST(addqueryfuncs, human_readable_size) {
479480
size *= 1024;
480481

481482
SNPRINTF(query, MAXSQL, "SELECT human_readable_size(%zu);", size + (size / 10));
482-
ASSERT_EQ(sqlite3_exec(db, query, str_output, output, nullptr), SQLITE_OK);
483+
ASSERT_EQ(sqlite3_exec(db, query, copy_columns_callback, &output, nullptr), SQLITE_OK);
483484
SNPRINTF(expected, MAXPATH, "1.1%c", SIZE[i]);
484485
EXPECT_STREQ(output, expected);
485486
}
486487

487-
ASSERT_EQ(sqlite3_exec(db, "SELECT human_readable_size('');", str_output, nullptr, nullptr), SQLITE_ERROR); /* empty input */
488-
ASSERT_EQ(sqlite3_exec(db, "SELECT human_readable_size('abc');", str_output, nullptr, nullptr), SQLITE_ERROR); /* non-integer input */
488+
ASSERT_EQ(sqlite3_exec(db, "SELECT human_readable_size('');", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* empty input */
489+
ASSERT_EQ(sqlite3_exec(db, "SELECT human_readable_size('abc');", copy_columns_callback, nullptr, nullptr), SQLITE_ERROR); /* non-integer input */
489490

490491
sqlite3_close(db);
491492
}
@@ -501,8 +502,9 @@ TEST(addqueryfuncs, level) {
501502
for(work.level = 0; work.level < 10; work.level++) {
502503
ASSERT_EQ(addqueryfuncs_with_context(db, &work), 0);
503504

504-
char output[MAXPATH] = {};
505-
ASSERT_EQ(sqlite3_exec(db, "SELECT level()", str_output, output, nullptr), SQLITE_OK);
505+
char buf[MAXPATH] = {};
506+
char *output = buf;
507+
ASSERT_EQ(sqlite3_exec(db, "SELECT level()", copy_columns_callback, &output, nullptr), SQLITE_OK);
506508

507509
char expected[MAXPATH] = {};
508510
SNPRINTF(expected, MAXPATH, "%zu", work.level);
@@ -525,8 +527,9 @@ TEST(addqueryfuncs, starting_point) {
525527

526528
ASSERT_EQ(addqueryfuncs_with_context(db, &work), 0);
527529

528-
char output[MAXPATH] = {};
529-
ASSERT_EQ(sqlite3_exec(db, "SELECT starting_point()", str_output, output, nullptr), SQLITE_OK);
530+
char buf[MAXPATH] = {};
531+
char *output = buf;
532+
ASSERT_EQ(sqlite3_exec(db, "SELECT starting_point()", copy_columns_callback, &output, nullptr), SQLITE_OK);
530533

531534
EXPECT_STREQ(output, work.orig_root.data);
532535

@@ -540,31 +543,32 @@ TEST(addqueryfuncs, basename) {
540543

541544
ASSERT_EQ(addqueryfuncs(db), 0);
542545

543-
char output[MAXPATH] = {};
546+
char buf[MAXPATH] = {};
547+
char *output = buf;
544548

545549
/* from basename(3) manpage */
546550

547-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('/usr/lib')", str_output, output, nullptr), SQLITE_OK);
551+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('/usr/lib')", copy_columns_callback, &output, nullptr), SQLITE_OK);
548552
EXPECT_STREQ(output, "lib");
549553

550-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('/usr/')", str_output, output, nullptr), SQLITE_OK);
554+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('/usr/')", copy_columns_callback, &output, nullptr), SQLITE_OK);
551555
EXPECT_STREQ(output, "usr");
552556

553-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('usr')", str_output, output, nullptr), SQLITE_OK);
557+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('usr')", copy_columns_callback, &output, nullptr), SQLITE_OK);
554558
EXPECT_STREQ(output, "usr");
555559

556-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('/')", str_output, output, nullptr), SQLITE_OK);
560+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('/')", copy_columns_callback, &output, nullptr), SQLITE_OK);
557561
EXPECT_STREQ(output, "/");
558562

559-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('.')", str_output, output, nullptr), SQLITE_OK);
563+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('.')", copy_columns_callback, &output, nullptr), SQLITE_OK);
560564
EXPECT_STREQ(output, ".");
561565

562-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('..')", str_output, output, nullptr), SQLITE_OK);
566+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename('..')", copy_columns_callback, &output, nullptr), SQLITE_OK);
563567
EXPECT_STREQ(output, "..");
564568

565569
/* not from manpage */
566570

567-
ASSERT_EQ(sqlite3_exec(db, "SELECT basename(NULL)", str_output, output, nullptr), SQLITE_OK);
571+
ASSERT_EQ(sqlite3_exec(db, "SELECT basename(NULL)", copy_columns_callback, &output, nullptr), SQLITE_OK);
568572
EXPECT_STREQ(output, "");
569573

570574
sqlite3_close(db);

0 commit comments

Comments
 (0)