1
2 /*********************************************************
3 * Soothsayer, an extensible predictive text entry system
4 * ------------------------------------------------------
5 *
6 * Copyright (C) 2008 Matteo Vescovi <matteo.vescovi@yahoo.co.uk>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 **********(*)*/
23
24 #include "sqliteDatabaseConnectorTest.h"
25
26 // for unlink(), getcwd()
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30
31 // for opendir(), readdir(), closedir(), DIR, dirent
32 #if HAVE_DIRENT_H
33 # include <dirent.h>
34 # define NAMLEN(dirent) strlen((dirent)->d_name)
35 #else
36 # define dirent direct
37 # define NAMLEN(dirent) (dirent)->d_namlen
38 # if HAVE_SYS_NDIR_H
39 # include <sys/ndir.h>
40 # endif
41 # if HAVE_SYS_DIR_H
42 # include <sys/dir.h>
43 # endif
44 # if HAVE_NDIR_H
45 # include <ndir.h>
46 # endif
47 #endif
48
49 #include <stdio.h>
50 #include <stdlib.h>
51
52 #include <fstream>
53
54 #include <assert.h>
55
56 CPPUNIT_TEST_SUITE_REGISTRATION( SqliteDatabaseConnectorTest );
57
setUp()58 void SqliteDatabaseConnectorTest::setUp()
59 {
60 CPPUNIT_ASSERT_NO_THROW(sqliteDatabaseConnector = new SqliteDatabaseConnector(DEFAULT_DATABASE_FILENAME));
61
62 unigram = new Ngram;
63 unigram->push_back("foo");
64
65 bigram = new Ngram;
66 bigram->push_back("foo");
67 bigram->push_back("bar");
68
69 trigram = new Ngram;
70 trigram->push_back("foo");
71 trigram->push_back("bar");
72 trigram->push_back("foobar");
73
74 unigram1 = new Ngram;
75 unigram1->push_back("foo1");
76
77 bigram1 = new Ngram;
78 bigram1->push_back("foo");
79 bigram1->push_back("bar1");
80
81 trigram1 = new Ngram;
82 trigram1->push_back("foo");
83 trigram1->push_back("bar");
84 trigram1->push_back("foobar1");
85 }
86
tearDown()87 void SqliteDatabaseConnectorTest::tearDown()
88 {
89 delete sqliteDatabaseConnector;
90
91 delete unigram;
92 delete bigram;
93 delete trigram;
94
95 delete unigram1;
96 delete bigram1;
97 delete trigram1;
98
99 assertExistsAndRemoveFile(DEFAULT_DATABASE_FILENAME);
100 }
101
testConstructor()102 void SqliteDatabaseConnectorTest::testConstructor()
103 {
104 std::cout << "SqliteDatabaseConnectorTest::testConstructor()" << std::endl;
105
106 // This tests that an empty database is created when an instance
107 // of SqliteDatabaseConstructor is created. The SqliteDatabase
108 // instantiation is done in the setUp() method and the testing is
109 // actually done in the tearDown() method.
110 }
111
testInsertNgram()112 void SqliteDatabaseConnectorTest::testInsertNgram()
113 {
114 std::cout << "SqliteDatabaseConnectorTest::testInsertNgram()" << std::endl;
115
116 // test that no insertion occurs since tables have not been
117 // yet created and an exception is thrown
118 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->insertNgram(*unigram, MAGIC_NUMBER),
119 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
120 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->insertNgram(*bigram, MAGIC_NUMBER),
121 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
122 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->insertNgram(*trigram, MAGIC_NUMBER),
123 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
124
125 // populate database
126 sqliteDatabaseConnector->createNgramTable(1);
127 sqliteDatabaseConnector->insertNgram(*unigram, MAGIC_NUMBER);
128
129 sqliteDatabaseConnector->createNgramTable(2);
130 sqliteDatabaseConnector->insertNgram(*bigram, MAGIC_NUMBER);
131
132 sqliteDatabaseConnector->createNgramTable(3);
133 sqliteDatabaseConnector->insertNgram(*trigram, MAGIC_NUMBER);
134
135 // compare database dump with benchmark string
136 std::stringstream benchmark;
137 benchmark
138 #if defined(HAVE_SQLITE3_H)
139 << "BEGIN TRANSACTION;" << std::endl
140 << "CREATE TABLE _1_gram (word TEXT, count INTEGER, UNIQUE(word) );" << std::endl
141 << "INSERT INTO \"_1_gram\" VALUES('foo', 1337);" << std::endl
142 << "CREATE TABLE _2_gram (word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_1, word) );" << std::endl
143 << "INSERT INTO \"_2_gram\" VALUES('foo', 'bar', 1337);" << std::endl
144 << "CREATE TABLE _3_gram (word_2 TEXT, word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_2, word_1, word) );" << std::endl
145 << "INSERT INTO \"_3_gram\" VALUES('foo', 'bar', 'foobar', 1337);" << std::endl
146 << "COMMIT;" << std::endl;
147 #elif defined(HAVE_SQLITE_H)
148 << "BEGIN TRANSACTION;" << std::endl
149 << "CREATE TABLE _1_gram (word TEXT, count INTEGER, UNIQUE(word) );" << std::endl
150 << "INSERT INTO _1_gram VALUES('foo',1337);" << std::endl
151 << "CREATE TABLE _2_gram (word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_1, word) );" << std::endl
152 << "INSERT INTO _2_gram VALUES('foo','bar',1337);" << std::endl
153 << "CREATE TABLE _3_gram (word_2 TEXT, word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_2, word_1, word) );" << std::endl
154 << "INSERT INTO _3_gram VALUES('foo','bar','foobar',1337);" << std::endl
155 << "COMMIT;" << std::endl;
156 #endif
157
158 assertDatabaseDumpEqualsBenchmark(benchmark);
159 }
160
testUpdateNgram()161 void SqliteDatabaseConnectorTest::testUpdateNgram()
162 {
163 std::cout << "SqliteDatabaseConnectorTest::testUpdateNgram()" << std::endl;
164
165 // test that no insertion occurs since tables have not been
166 // yet created and an exception is thrown
167 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->updateNgram(*unigram, MAGIC_NUMBER),
168 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
169 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->updateNgram(*bigram, MAGIC_NUMBER),
170 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
171 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->updateNgram(*trigram, MAGIC_NUMBER),
172 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
173
174 // populate database
175 sqliteDatabaseConnector->createNgramTable(1);
176 sqliteDatabaseConnector->insertNgram(*unigram, MAGIC_NUMBER);
177 sqliteDatabaseConnector->updateNgram(*unigram, MAGIC_NUMBER * 2);
178
179 sqliteDatabaseConnector->createNgramTable(2);
180 sqliteDatabaseConnector->insertNgram(*bigram, MAGIC_NUMBER);
181 sqliteDatabaseConnector->updateNgram(*bigram, MAGIC_NUMBER * 2);
182
183 sqliteDatabaseConnector->createNgramTable(3);
184 sqliteDatabaseConnector->insertNgram(*trigram, MAGIC_NUMBER);
185 sqliteDatabaseConnector->updateNgram(*trigram, MAGIC_NUMBER * 2);
186
187 // compare database dump with benchmark string
188 std::stringstream benchmark;
189 benchmark
190 << "BEGIN TRANSACTION;" << std::endl
191 << "CREATE TABLE _1_gram (word TEXT, count INTEGER, UNIQUE(word) );" << std::endl
192 #if defined(HAVE_SQLITE3_H)
193 << "INSERT INTO \"_1_gram\" VALUES('foo', 2674);" << std::endl
194 #elif defined(HAVE_SQLITE_H)
195 << "INSERT INTO _1_gram VALUES('foo',2674);" << std::endl
196 #endif
197 << "CREATE TABLE _2_gram (word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_1, word) );" << std::endl
198 #if defined(HAVE_SQLITE3_H)
199 << "INSERT INTO \"_2_gram\" VALUES('foo', 'bar', 2674);" << std::endl
200 #elif defined(HAVE_SQLITE_H)
201 << "INSERT INTO _2_gram VALUES('foo','bar',2674);" << std::endl
202 #endif
203 << "CREATE TABLE _3_gram (word_2 TEXT, word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_2, word_1, word) );" << std::endl
204 #if defined(HAVE_SQLITE3_H)
205 << "INSERT INTO \"_3_gram\" VALUES('foo', 'bar', 'foobar', 2674);" << std::endl
206 #elif defined(HAVE_SQLITE_H)
207 << "INSERT INTO _3_gram VALUES('foo','bar','foobar',2674);" << std::endl
208 #endif
209 << "COMMIT;" << std::endl;
210
211 assertDatabaseDumpEqualsBenchmark(benchmark);
212 }
213
testRemoveNgram()214 void SqliteDatabaseConnectorTest::testRemoveNgram()
215 {
216 //CPPUNIT_FAIL("Test not written yet!");
217 }
218
testGetNgramCount()219 void SqliteDatabaseConnectorTest::testGetNgramCount()
220 {
221 std::cout << "SqliteDatabaseConnectorTest::testGetNgramCount()" << std::endl;
222
223 // populate database
224 sqliteDatabaseConnector->createNgramTable(1);
225 sqliteDatabaseConnector->insertNgram(*unigram, MAGIC_NUMBER);
226
227 sqliteDatabaseConnector->createNgramTable(2);
228 sqliteDatabaseConnector->insertNgram(*bigram, MAGIC_NUMBER);
229
230 sqliteDatabaseConnector->createNgramTable(3);
231 sqliteDatabaseConnector->insertNgram(*trigram, MAGIC_NUMBER);
232
233 CPPUNIT_ASSERT_EQUAL( MAGIC_NUMBER,
234 sqliteDatabaseConnector->getNgramCount(*unigram) );
235 CPPUNIT_ASSERT_EQUAL( MAGIC_NUMBER,
236 sqliteDatabaseConnector->getNgramCount(*bigram) );
237 CPPUNIT_ASSERT_EQUAL( MAGIC_NUMBER,
238 sqliteDatabaseConnector->getNgramCount(*trigram) );
239
240 // Add crafted unigram to database to test that WHERE word =
241 // "word" bug has been fixed. Fix is using WHERE word = 'word'
242 // clause.
243 // A keyword in single quotes is interpreted as a literal string
244 // if it occurs in a context where a string literal is allowed,
245 // otherwise it is understood as an identifier, whereas a
246 // keyword in double-quotes is interpreted as an identifier if
247 // it matches a known identifier - otherwise it is interpreted
248 // as a string literal. The following WHERE word = "word" is a
249 // no-op, the correct clause is WHERE word = 'word'.
250 Ngram* ngram = new Ngram();
251 ngram->push_back("word");
252 sqliteDatabaseConnector->insertNgram(*ngram, MAGIC_NUMBER + 1);
253 CPPUNIT_ASSERT_EQUAL( MAGIC_NUMBER + 1,
254 sqliteDatabaseConnector->getNgramCount(*ngram) );
255 delete ngram;
256 }
257
testIncrementNgramCount()258 void SqliteDatabaseConnectorTest::testIncrementNgramCount()
259 {
260 std::cout << "SqliteDatabaseConnectorTest::testIncrementNgramCount()" << std::endl;
261
262 // test that no insertion occurs since tables have not been
263 // yet created
264 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->incrementNgramCount(*unigram),
265 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
266 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->incrementNgramCount(*bigram),
267 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
268 CPPUNIT_ASSERT_THROW(sqliteDatabaseConnector->incrementNgramCount(*trigram),
269 SqliteDatabaseConnector::SqliteDatabaseConnectorException);
270
271 // populate database
272 sqliteDatabaseConnector->createNgramTable(1);
273 sqliteDatabaseConnector->incrementNgramCount(*unigram);
274 sqliteDatabaseConnector->incrementNgramCount(*unigram);
275 sqliteDatabaseConnector->incrementNgramCount(*unigram);
276
277 sqliteDatabaseConnector->createNgramTable(2);
278 sqliteDatabaseConnector->incrementNgramCount(*bigram);
279 sqliteDatabaseConnector->incrementNgramCount(*bigram);
280 sqliteDatabaseConnector->incrementNgramCount(*bigram);
281
282 sqliteDatabaseConnector->createNgramTable(3);
283 sqliteDatabaseConnector->incrementNgramCount(*trigram);
284 sqliteDatabaseConnector->incrementNgramCount(*trigram);
285 sqliteDatabaseConnector->incrementNgramCount(*trigram);
286
287 // compare database dump with benchmark string
288 std::stringstream benchmark;
289 benchmark
290 << "BEGIN TRANSACTION;" << std::endl
291 << "CREATE TABLE _1_gram (word TEXT, count INTEGER, UNIQUE(word) );" << std::endl
292 #if defined(HAVE_SQLITE3_H)
293 << "INSERT INTO \"_1_gram\" VALUES('foo', 3);" << std::endl
294 #elif defined(HAVE_SQLITE_H)
295 << "INSERT INTO _1_gram VALUES('foo',3);" << std::endl
296 #endif
297 << "CREATE TABLE _2_gram (word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_1, word) );" << std::endl
298 #if defined(HAVE_SQLITE3_H)
299 << "INSERT INTO \"_2_gram\" VALUES('foo', 'bar', 3);" << std::endl
300 #elif defined(HAVE_SQLITE_H)
301 << "INSERT INTO _2_gram VALUES('foo','bar',3);" << std::endl
302 #endif
303 << "CREATE TABLE _3_gram (word_2 TEXT, word_1 TEXT, word TEXT, count INTEGER, UNIQUE(word_2, word_1, word) );" << std::endl
304 #if defined(HAVE_SQLITE3_H)
305 << "INSERT INTO \"_3_gram\" VALUES('foo', 'bar', 'foobar', 3);" << std::endl
306 #elif defined(HAVE_SQLITE_H)
307 << "INSERT INTO _3_gram VALUES('foo','bar','foobar',3);" << std::endl
308 #endif
309 << "COMMIT;" << std::endl;
310
311 assertDatabaseDumpEqualsBenchmark(benchmark);
312 }
313
testGetNgramLikeTable()314 void SqliteDatabaseConnectorTest::testGetNgramLikeTable()
315 {
316 std::cout << "SqliteDatabaseConnectorTest::testGetNgramLikeTable()" << std::endl;
317
318 // populate database
319 sqliteDatabaseConnector->createNgramTable(1);
320 sqliteDatabaseConnector->insertNgram(*unigram, MAGIC_NUMBER);
321
322 sqliteDatabaseConnector->createNgramTable(2);
323 sqliteDatabaseConnector->insertNgram(*bigram, MAGIC_NUMBER);
324
325 sqliteDatabaseConnector->createNgramTable(3);
326 sqliteDatabaseConnector->insertNgram(*trigram, MAGIC_NUMBER);
327
328 NgramTable* expected_uni;
329 NgramTable* expected_bi;
330 NgramTable* expected_tri;
331 NgramTable actual;
332
333 Ngram* ngram;
334
335 expected_uni = new NgramTable();
336 ngram = new Ngram();
337 ngram->push_back("foo");
338 ngram->push_back("1337");
339 expected_uni->push_back(*ngram);
340 actual = sqliteDatabaseConnector->getNgramLikeTable(*unigram);
341 assertEqualNgramTable(expected_uni, actual);
342 delete ngram;
343
344 expected_bi = new NgramTable();
345 ngram = new Ngram();
346 ngram->push_back("foo");
347 ngram->push_back("bar");
348 ngram->push_back("1337");
349 expected_bi->push_back(*ngram);
350 actual = sqliteDatabaseConnector->getNgramLikeTable(*bigram);
351 assertEqualNgramTable(expected_bi, actual);
352 delete ngram;
353
354 expected_tri = new NgramTable();
355 ngram = new Ngram();
356 ngram->push_back("foo");
357 ngram->push_back("bar");
358 ngram->push_back("foobar");
359 ngram->push_back("1337");
360 expected_tri->push_back(*ngram);
361 actual = sqliteDatabaseConnector->getNgramLikeTable(*trigram);
362 assertEqualNgramTable(expected_tri, actual);
363 delete ngram;
364
365 // add similar ngrams to database
366 sqliteDatabaseConnector->insertNgram(*unigram1, MAGIC_NUMBER - 1);
367 sqliteDatabaseConnector->insertNgram(*bigram1, MAGIC_NUMBER - 1);
368 sqliteDatabaseConnector->insertNgram(*trigram1, MAGIC_NUMBER - 1);
369
370 ngram = new Ngram();
371 ngram->push_back("foo1");
372 ngram->push_back("1336");
373 expected_uni->push_back(*ngram);
374 actual = sqliteDatabaseConnector->getNgramLikeTable(*unigram);
375 assertEqualNgramTable(expected_uni, actual);
376 delete ngram;
377
378 ngram = new Ngram();
379 ngram->push_back("foo");
380 ngram->push_back("bar1");
381 ngram->push_back("1336");
382 expected_bi->push_back(*ngram);
383 actual = sqliteDatabaseConnector->getNgramLikeTable(*bigram);
384 assertEqualNgramTable(expected_bi, actual);
385 delete ngram;
386
387 ngram = new Ngram();
388 ngram->push_back("foo");
389 ngram->push_back("bar");
390 ngram->push_back("foobar1");
391 ngram->push_back("1336");
392 expected_tri->push_back(*ngram);
393 actual = sqliteDatabaseConnector->getNgramLikeTable(*trigram);
394 assertEqualNgramTable(expected_tri, actual);
395 delete ngram;
396
397 delete expected_uni;
398 delete expected_bi;
399 delete expected_tri;
400 }
401
assertEqualNgramTable(const NgramTable * const expected,const NgramTable & actual)402 void SqliteDatabaseConnectorTest::assertEqualNgramTable(const NgramTable* const expected, const NgramTable& actual)
403 {
404 CPPUNIT_ASSERT_EQUAL(expected->size(), actual.size());
405 for (size_t i = 0; i < expected->size(); i++) {
406 CPPUNIT_ASSERT_EQUAL((*expected)[i].size(), actual[i].size());
407 for (size_t j = 0; j < (*expected)[i].size(); j++) {
408 std::cout << "[assertEqualNgramTable] (" << (*expected)[i][j] << ", " << actual[i][j] << ")" << std::endl;
409 CPPUNIT_ASSERT((*expected)[i][j] == actual[i][j]);
410 }
411 }
412 }
413
assertExistsAndRemoveFile(const char * filename) const414 void SqliteDatabaseConnectorTest::assertExistsAndRemoveFile(const char* filename) const
415 {
416 #ifdef HAVE_DIRENT_H
417 bool result = false;
418 DIR* dp;
419 struct dirent *ep;
420
421 // check if file exists in current directory
422 dp = opendir ("./");
423 if (dp != NULL) {
424 while ((ep = readdir (dp)) && (result == 0)) {
425 if (strcmp(ep->d_name, filename) == 0) {
426 result = true;
427 }
428 }
429 (void) closedir (dp);
430 } else {
431 perror ("[SqliteDatabaseConnectorTest] Couldn't open current directory!");
432 }
433
434 CPPUNIT_ASSERT( result == true );
435 #else
436 // if we cannot determine file existance, let us assume that file
437 // exists
438 bool result = true;
439 #endif
440
441 #ifdef HAVE_UNISTD_H
442 // remove file if it exists
443 if (result) {
444 result = unlink(filename);
445 assert(result == 0);
446 }
447 #else
448 // fail test
449 std::string message = "Unable to remove database file ";
450 message += filename;
451 CPPUNIT_FAIL( message.c_str() );
452 //exit(-1);
453 #endif
454 }
455
assertDatabaseDumpEqualsBenchmark(std::stringstream & benchmark) const456 void SqliteDatabaseConnectorTest::assertDatabaseDumpEqualsBenchmark(std::stringstream& benchmark) const
457 {
458 // dump database content using `sqlite' client
459 std::string command =
460 #if defined(HAVE_SQLITE3_H)
461 static_cast<std::string>("sqlite3 ")
462 #elif defined(HAVE_SQLITE_H)
463 static_cast<std::string>("sqlite ")
464 #endif
465 + DEFAULT_DATABASE_FILENAME + " '.dump' > " + DATABASE_DUMP;
466
467 int result = system(command.c_str());
468 CPPUNIT_ASSERT(result == 0);
469
470 std::ifstream database_dump_stream(DATABASE_DUMP);
471
472 // NOTE: this block of code has been commented out to account for
473 // the fact that different versions of the sqlite/sqlite3 binary
474 // return slightly different dumps of the same database. The
475 // differences are limited to whitespace, single quotes, or double
476 // quotes; but they do make a stream length comparison
477 // inconclusive as to determine if two streams are a dump of the
478 // same database.
479 //
480 // assert streams contain equal number of characters
481 //
482 //benchmark.seekg(0, std::ios::end);
483 //database_dump_stream.seekg(0, std::ios::end);
484 //CPPUNIT_ASSERT( benchmark.tellg() == database_dump_stream.tellg() );
485 //benchmark.seekg(0);
486 //database_dump_stream.seekg(0);
487
488 // assert streams contain same characters
489 std::string actual;
490 std::string expected;
491 bool equal = true;;
492 while (getline(database_dump_stream, actual)
493 && getline(benchmark, expected)) {
494 // remove " and ' from strings, because different versions of
495 // sqlite insert either double quotes or single quotes or no
496 // quotes at all.
497 strip_char('"', actual);
498 strip_char('\'', actual);
499 strip_char('"', expected);
500 strip_char('\'', expected);
501 // also remove space from strings
502 // TODO: removing space is not bulletproof, i.e. a really
503 // difference in the SQL might slip by unseen.
504 strip_char(' ', actual);
505 strip_char(' ', expected);
506
507 equal = (expected == actual);
508 //if (!equal)
509 std::cout << "[expected} " << expected << " [actual] " << actual << std::endl;
510 CPPUNIT_ASSERT(equal);
511 }
512
513 assertExistsAndRemoveFile(DATABASE_DUMP);
514
515 ////
516 // Using pipes instead of writing to a temp file.
517 // Currently does not work.
518 //
519 // std::string command = static_cast<std::string>("sqlite ") + DEFAULT_DATABASE_FILENAME + " '.dump' > " + DATABASE_DUMP;
520 // FILE* pipe = popen(command.c_str(), "r");
521 // while (!feof(pipe) && !ferror(pipe)) {
522 // std::cout << static_cast<char>(fgetc(pipe));
523 // }
524 //
525 // CPPUNIT_ASSERT( pipe != NULL );
526 // if (pipe) {
527 // int expected;
528 // int actual;
529 // while(benchmark.good() && !feof(pipe) && !ferror(pipe)) {
530 // expected = benchmark.get();
531 // actual = fgetc(pipe);
532 //
533 // std::cout << "[expected] " << static_cast<char>(expected)
534 // << " [actual] " << static_cast<char>(actual) << std::endl;
535 //
536 //
537 // CPPUNIT_ASSERT_EQUAL( expected, actual );
538 // }
539 //
540 // pclose(pipe);
541 // } else {
542 // CPPUNIT_FAIL( "Unable to open pipe to execute `sqlite'" );
543 // }
544 }
545
strip_char(char c,std::string & str) const546 void SqliteDatabaseConnectorTest::strip_char(char c, std::string& str) const
547 {
548 //std::cout << "string before: " << str << std::endl;
549 std::string::size_type pos = 0;
550 while ((pos = str.find(c, pos)) != std::string::npos) {
551 str.erase(pos, 1);
552 //std::cout << "pos: " << pos << "string: " << str << std::endl;
553 }
554 //std::cout << "string after : " << str << std::endl;
555 }
556