IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 29, 2005, 12:14:48 PM (21 years ago)
Author:
asc
Message:

bugfixes and get more tests to run

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/dataIO/tst_psDB.c

    r3531 r3545  
    11/** @file  tst_psDB.c
    2 *
    3 * -*- mode: C; c-basic-indent: 4; tab-width: 8; indent-tabs-mode: nil -*-
    4 * vim: set cindent ts=8 sw=4 expandtab:
    5 *
    6 *  @brief Contains the tests for psDB.[ch]
    7 *
    8 *
    9 *  @author Aaron Culliney, MHPCC
    10 *
    11 *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2005-03-28 22:52:32 $
    13 *
    14 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    15 *
    16 */
     2 *
     3 * -*- mode: C; c-basic-indent: 4; tab-width: 8; indent-tabs-mode: nil -*-
     4 * vim: set cindent ts=8 sw=4 expandtab:
     5 *
     6 *  @brief Contains the tests for psDB.[ch]
     7 *
     8 *
     9 *  @author Aaron Culliney, MHPCC
     10 *
     11 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-03-29 22:14:48 $
     13 *
     14 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
     15 *
     16 */
    1717
    1818#define PS_ALLOW_MALLOC // for MySQL internals ...
    … …  
    3030
    3131static psDB *_init_psDB( void );
    32 static void  _cleanup_psDB(psDB *dbh);
    3332static psMetadata *_get_CreateTableMetadata( void );
    3433static psMetadata *_get_RowMetadataValues(const char *val0, psS32 val1, psF32 val2, psF64 val3);
    … …  
    6059testDescription tests[] = {
    6160                              {TPDBInit,            -1,  "dbInit",            0, false},
    62                               {TPDBCreateTable,     -1,  "dbCreateTable",     0, false},
    63                               {TPDBDropTable,       -2,  "dbDropTable",       0, true},
    64                               {TPDBSelectColumn,    -3,  "dbSelectColumn",    0, true},
    65                               {TPDBSelectColumnNum, -4,  "dbSelectColumnNum", 0, true},
    66                               {TPDBSelectRows,      -5,  "dbSelectRows",      0, true},
    67                               {TPDBInsertOneRow,    -6,  "dbInsertOneRow",    0, true},
    68                               {TPDBInsertRows,      -7,  "dbInsertRows",      0, true},
    69                               {TPDBDumpRows,        -8,  "dbDumpRows",        0, true},
    70                               {TPDBDumpCols,        -9,  "dbDumpCols",        0, true},
    71                               {TPDBUpdateRows,      -10, "dbUpdateRows",      0, true},
    72                               {TPDBDeleteRows,      -11, "dbDeleteRows",      0, true},
    73                               {TPDBChange,          -12, "dbChange",          0, true},
    74                               //{TPDBCreate,        -15, "dbCreate",          0, false},
    75                               //{TPDBDrop,          -16, "dbDrop",            0, false},
     61                              {TPDBChange,          -2,  "dbChange",          0, false},
     62                              {TPDBCreateTable,     -3,  "dbCreateTable",     0, false},
     63                              {TPDBDropTable,       -4,  "dbDropTable",       0, false},
     64                              {TPDBSelectColumn,    -5,  "dbSelectColumn",    0, false},
     65                              {TPDBSelectColumnNum, -6,  "dbSelectColumnNum", 0, false},
     66                              {TPDBSelectRows,      -7,  "dbSelectRows",      0, false},
     67                              {TPDBInsertOneRow,    -8,  "dbInsertOneRow",    0, false},
     68                              {TPDBInsertRows,      -9,  "dbInsertRows",      0, false},
     69                              {TPDBDumpRows,        -10, "dbDumpRows",        0, false},
     70                              {TPDBDumpCols,        -11, "dbDumpCols",        0, false},
     71                              {TPDBUpdateRows,      -12, "dbUpdateRows",      0, false},
     72                              {TPDBDeleteRows,      -13, "dbDeleteRows",      0, false},
     73                              //{TPDBCreate,        -14, "dbCreate",          0, false},
     74                              //{TPDBDrop,          -15, "dbDrop",            0, false},
    7675                              {NULL}
    7776                          };
    … …  
    9594
    9695    return dbh;
    97 }
    98 
    99 // internal method to handle DB cleanup
    100 void _cleanup_psDB(psDB *dbh)
    101 {
    102     psDBCleanup(dbh);
    10396}
    10497
    … …  
    135128        return NULL;
    136129    }
    137     str = psMetadataItemAllocStr(key0, comm0, val0);
    138     //psLogMsg( __func__, PS_LOG_INFO, "MetaDataItemType (%d).\n", str->type );
     130    if (key0 != NULL) {
     131        str = psMetadataItemAllocStr(key0, comm0, val0);
     132    }
    139133    s32 = psMetadataItemAllocS32(key1, comm1, val1);
    140     //psLogMsg( __func__, PS_LOG_INFO, "MetaDataItemType (%d).\n", s32->type );
    141134    f32 = psMetadataItemAllocF32(key2, comm2, val2);
    142     //psLogMsg( __func__, PS_LOG_INFO, "MetaDataItemType (%d).\n", f32->type );
    143135    f64 = psMetadataItemAllocF64(key3, comm3, val3);
    144     //psLogMsg( __func__, PS_LOG_INFO, "MetaDataItemType (%d).\n", f64->type );
    145     if ((str == NULL) || (s32 == NULL) || (f32 == NULL) || (f64 == NULL)) {
     136    if ( ((key0 != NULL) && (str == NULL)) || (s32 == NULL) || (f32 == NULL) || (f64 == NULL)) {
    146137        psError(PS_ERR_UNKNOWN, true, "could not create psMetadataItem(s) in %s!", __func__ );
    147138        return NULL;
    148139    }
    149     if ( !psMetadataAddItem(md, str, 0, 0) || !psMetadataAddItem(md, s32, 0, 0) ||
     140    if ( ((key0 != NULL) && !psMetadataAddItem(md, str, 0, 0)) || !psMetadataAddItem(md, s32, 0, 0) ||
    150141            !psMetadataAddItem(md, f32, 0, 0) || !psMetadataAddItem(md, f64, 0, 0)) {
    151142        psError(PS_ERR_UNKNOWN, true, "could not add psMetadataItem(s) to psMetadata in %s!", __func__ );
    … …  
    153144    }
    154145
     146    if (str != NULL) {
     147        psFree(str);
     148    }
     149    psFree(s32);
     150    psFree(f32);
     151    psFree(f64);
     152
    155153    return md;
    156 }
    157 
    158 void _cleanup_Metadata (psMetadata *md)
    159 {
    160     psMetadataItem* item = NULL;
    161     psMetadataIterator* mdi = psMetadataIteratorAlloc(md, 0, NULL);
    162     while ((item = psMetadataGetAndIncrement(mdi)) != NULL) {
    163         psFree(item);
    164     }
    165     psFree(mdi);
    166     psFree(md);
    167154}
    168155
    … …  
    178165psMetadata *_get_where( void )
    179166{
    180     return _get_row();
     167    return _get_RowMetadata(
     168               NULL, NULL, NULL,
     169               "key_s32",    "comment-s32",     1974,
     170               "key_f32",    "comment-f32",     3.14159,
     171               "key_f64",    "comment-f64",     2.71828);
    181172}
    182173
    … …  
    206197    }
    207198
    208     _cleanup_psDB(dbh);
    209 
    210     return failed;
    211 }
    212 
    213 // Testpoint #XXX, psDBCreate shall create a new test database.
    214 psS32 TPDBCreate( void )
    215 {
    216     const char *test_db = "ps_test_db";
    217     psS32 failed = 0;
    218     psDB *dbh = NULL;
    219 
    220     dbh = _init_psDB();
    221     if (dbh == NULL) {
    222         return 1;
    223     }
    224 
    225     psLogMsg( __func__, PS_LOG_INFO, "psDBCreate shall create new new test database.\n" );
    226 
    227     failed = ! psDBCreate(dbh, test_db);
    228     if (!failed) {
    229         psDBDrop(dbh, test_db);
    230     }
    231 
    232     _cleanup_psDB(dbh);
    233 
    234     return failed;
    235 }
    236 
    237 // Testpoint #XXX, psDBDrop shall create a new test database.
    238 psS32 TPDBDrop( void )
    239 {
    240     const char *test_db = "ps_test_db";
    241     psS32 failed = 0;
    242     psDB *dbh = NULL;
    243 
    244     dbh = _init_psDB();
    245     if (dbh == NULL) {
    246         return 1;
    247     }
    248 
    249     psLogMsg( __func__, PS_LOG_INFO, "psDBDrop shall create/drop a new new test database.\n" );
    250 
    251     failed = psDBCreate(dbh, test_db);
    252     if (!failed) {
    253         failed = ! psDBDrop(dbh, test_db);
    254     }
    255 
    256     _cleanup_psDB(dbh);
     199    psDBCleanup(dbh);
    257200
    258201    return failed;
    … …  
    274217    failed = ! psDBChange(dbh, dbname);
    275218
    276     _cleanup_psDB(dbh);
     219    psDBCleanup(dbh);
    277220
    278221    return failed;
    … …  
    299242    }
    300243
    301     _cleanup_Metadata(md);
    302 
    303     _cleanup_psDB(dbh);
     244    psFree(md);
     245    psDBCleanup(dbh);
    304246
    305247    return failed;
    … …  
    312254    psDB *dbh = NULL;
    313255    const char* table = "table2";
     256    psMetadata *md = _get_CreateTableMetadata();
    314257
    315258    dbh = _init_psDB();
    … …  
    320263    psLogMsg( __func__, PS_LOG_INFO, "psDBDropTable shall create/drop a new table in the new test database.\n" );
    321264
    322     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
     265    failed = ! psDBCreateTable(dbh, table, md);
    323266    if (!failed) {
    324267        failed = ! psDBDropTable(dbh, table);
    325268    }
    326269
    327     _cleanup_psDB(dbh);
     270    psFree(md);
     271    psDBCleanup(dbh);
    328272
    329273    return failed;
    … …  
    337281    const char* table = "table3";
    338282    psArray *ary = NULL;
     283    psMetadata *md = _get_CreateTableMetadata();
    339284
    340285    dbh = _init_psDB();
    … …  
    345290    psLogMsg( __func__, PS_LOG_INFO, "psDBSelectColumn shall select data from a test table.\n" );
    346291
    347     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    348     if (!failed) {
    349         ary = psDBSelectColumn(dbh, table, "", 1);
    350         failed = (ary == NULL);
    351         psDBDropTable(dbh, table);
    352     }
    353 
    354     _cleanup_psDB(dbh);
     292    failed = ! psDBCreateTable(dbh, table, md);
     293    if (!failed) {
     294        ary = psDBSelectColumn(dbh, table, "key_string", 1);
     295        if (ary == NULL) {
     296            failed = 1;
     297        } else {
     298            psFree(ary);
     299        }
     300        psDBDropTable(dbh, table);
     301    }
     302
     303    psFree(md);
     304    psDBCleanup(dbh);
    355305
    356306    return failed;
    … …  
    364314    const char* table = "table4";
    365315    psVector *vec = NULL;
     316    psMetadata *md = _get_CreateTableMetadata();
    366317
    367318    dbh = _init_psDB();
    … …  
    372323    psLogMsg( __func__, PS_LOG_INFO, "psDBSelectColumnNum shall select data from a test table.\n" );
    373324
    374     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    375     if (!failed) {
    376         vec = psDBSelectColumnNum(dbh, table, "key-string", PS_TYPE_PTR, 1);
    377         failed = (vec == NULL);
    378         psDBDropTable(dbh, table);
    379     }
    380 
    381     _cleanup_psDB(dbh);
     325    failed = ! psDBCreateTable(dbh, table, md);
     326    if (!failed) {
     327        vec = psDBSelectColumnNum(dbh, table, "key_string", PS_TYPE_PTR, 1);
     328        if (vec == NULL) {
     329            failed = 1;
     330        } else {
     331            psFree(vec);
     332        }
     333        psDBDropTable(dbh, table);
     334    }
     335
     336    psFree(md);
     337    psDBCleanup(dbh);
    382338
    383339    return failed;
    … …  
    391347    const char* table = "table5";
    392348    psArray *ary = NULL;
     349    psMetadata *where=NULL, *row=NULL, *md = _get_CreateTableMetadata();
    393350
    394351    dbh = _init_psDB();
    … …  
    399356    psLogMsg( __func__, PS_LOG_INFO, "psDBSelectRows shall select data from a test table.\n" );
    400357
    401     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    402     if (!failed) {
    403         psDBInsertOneRow(dbh, table, _get_row());             // 3X rows for general case
    404         psDBInsertOneRow(dbh, table, _get_row());
    405         failed = ! psDBInsertOneRow(dbh, table, _get_row());
     358    failed = ! psDBCreateTable(dbh, table, md);
     359    if (!failed) {
     360
     361        row = _get_row();
     362        psDBInsertOneRow(dbh, table, row);
     363        psFree(row);
     364
     365        row = _get_row();
     366        psDBInsertOneRow(dbh, table, row);
     367        psFree(row);
     368
     369        row = _get_row();
     370        failed = ! psDBInsertOneRow(dbh, table, row);
     371        psFree(row);
     372
    406373        if (!failed) {
    407             ary = psDBSelectRows(dbh, table, _get_where(), 0);
    408             failed = (ary == NULL);
     374            where = _get_where();
     375            ary = psDBSelectRows(dbh, table, /*NULL*/where, 0);
     376            psFree(where);
     377            if (ary == NULL) {
     378                failed = 1;
     379            } else {
     380                psFree(ary);
     381            }
    409382        }
    410383        psDBDropTable(dbh, table);
    411384    }
    412385
    413     _cleanup_psDB(dbh);
     386    psFree(md);
     387    psDBCleanup(dbh);
    414388
    415389    return failed;
    … …  
    422396    psDB *dbh = NULL;
    423397    const char* table = "table6";
     398    psMetadata *row=NULL, *md = _get_CreateTableMetadata();
    424399
    425400    dbh = _init_psDB();
    … …  
    430405    psLogMsg( __func__, PS_LOG_INFO, "psDBInsertOneRow shall insert a row into a test table.\n" );
    431406
    432     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    433     if (!failed) {
    434         failed = ! psDBInsertOneRow(dbh, table, _get_row());
    435         psDBDropTable(dbh, table);
    436     }
    437 
    438     _cleanup_psDB(dbh);
     407    failed = ! psDBCreateTable(dbh, table, md);
     408    if (!failed) {
     409        row = _get_row();
     410        failed = ! psDBInsertOneRow(dbh, table, row);
     411        psFree(row);
     412        psDBDropTable(dbh, table);
     413    }
     414
     415    psFree(md);
     416    psDBCleanup(dbh);
    439417
    440418    return failed;
    … …  
    448426    const char* table = "table7";
    449427    psArray *rowSet = NULL;
     428    psMetadata *row=NULL, *md = _get_CreateTableMetadata();
    450429
    451430    dbh = _init_psDB();
    … …  
    456435    psLogMsg( __func__, PS_LOG_INFO, "psDBInsertRows shall insert rows into a test table.\n" );
    457436
    458     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    459     if (!failed) {
    460         rowSet = psArrayAlloc(1);
     437    failed = ! psDBCreateTable(dbh, table, md);
     438    if (!failed) {
     439        rowSet = psArrayAlloc(3);
    461440        rowSet->n = 0;
    462         psArrayAdd(rowSet, 0, _get_row());
    463         psArrayAdd(rowSet, 0, _get_row());
    464         psArrayAdd(rowSet, 0, _get_row());
     441
     442        row = _get_row();
     443        psArrayAdd(rowSet, 0, row);
     444        psFree(row);
     445
     446        row = _get_row();
     447        psArrayAdd(rowSet, 0, row);
     448        psFree(row);
     449
     450        row = _get_row();
     451        psArrayAdd(rowSet, 0, row);
     452        psFree(row);
     453
    465454        failed = ! psDBInsertRows(dbh, table, rowSet);
    466         psDBDropTable(dbh, table);
    467     }
    468 
    469     _cleanup_psDB(dbh);
     455        psFree(rowSet);
     456
     457        psDBDropTable(dbh, table);
     458    }
     459
     460    psFree(md);
     461    psDBCleanup(dbh);
    470462
    471463    return failed;
    … …  
    478470    psDB *dbh = NULL;
    479471    const char* table = "table8";
     472    psArray *ary = NULL;
     473    psMetadata *row=NULL, *md = _get_CreateTableMetadata();
     474
     475    dbh = _init_psDB();
     476    if (dbh == NULL) {
     477        return 1;
     478    }
     479
     480    psLogMsg( __func__, PS_LOG_INFO, "psDBDumpRows shall dump all rows from a test table.\n" );
     481
     482    failed = ! psDBCreateTable(dbh, table, md);
     483    if (!failed) {
     484
     485        row = _get_row();
     486        psDBInsertOneRow(dbh, table, row);
     487        psFree(row);
     488
     489        row = _get_row();
     490        psDBInsertOneRow(dbh, table, row);
     491        psFree(row);
     492
     493        row = _get_row();
     494        failed = ! psDBInsertOneRow(dbh, table, row);
     495        psFree(row);
     496
     497        if (!failed) {
     498            ary = psDBDumpRows(dbh, table);
     499            if (ary == NULL) {
     500                failed = 1;
     501            } else {
     502                psFree(ary);
     503            }
     504        }
     505
     506        psDBDropTable(dbh, table);
     507    }
     508
     509    psFree(md);
     510    psDBCleanup(dbh);
     511
     512    return failed;
     513}
     514
     515// Testpoint #XXX, TPDBDumpCols shall dump all cols from a test table ...
     516psS32 TPDBDumpCols( void )
     517{
     518    psS32 failed = 0;
     519    psDB *dbh = NULL;
     520    const char* table = "table9";
     521    psMetadata *meta=NULL, *md = _get_CreateTableMetadata();
     522
     523    dbh = _init_psDB();
     524    if (dbh == NULL) {
     525        return 1;
     526    }
     527
     528    psLogMsg( __func__, PS_LOG_INFO, "psDBDumpCols shall dump all cols from a test table.\n" );
     529
     530    failed = ! psDBCreateTable(dbh, table, md);
     531    if (!failed) {
     532        meta = psDBDumpCols(dbh, table);
     533        if (meta == NULL) {
     534            failed = 1;
     535        } else {
     536            psFree(meta);
     537        }
     538        psDBDropTable(dbh, table);
     539    }
     540
     541    psFree(md);
     542    psDBCleanup(dbh);
     543
     544    return failed;
     545}
     546
     547// Testpoint #XXX, TPDBUpdateRows shall update rows in a test table ...
     548psS32 TPDBUpdateRows( void )
     549{
     550    psS32 failed = 0;
     551    psDB *dbh = NULL;
     552    const char* table = "table10";
    480553    psArray *rowSet = NULL;
    481     psArray *ary = NULL;
    482 
    483     dbh = _init_psDB();
    484     if (dbh == NULL) {
    485         return 1;
    486     }
    487 
    488     psLogMsg( __func__, PS_LOG_INFO, "psDBDumpRows shall dump all rows from a test table.\n" );
    489 
    490     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    491     if (!failed) {
    492         rowSet = psArrayAlloc(1);
     554    psMetadata *row=NULL, *where=NULL, *updates=NULL, *md = _get_CreateTableMetadata();
     555
     556    dbh = _init_psDB();
     557    if (dbh == NULL) {
     558        return 1;
     559    }
     560
     561    psLogMsg( __func__, PS_LOG_INFO, "psDBUpdateRows shall update rows in a test table.\n" );
     562
     563    failed = ! psDBCreateTable(dbh, table, md);
     564    if (!failed) {
     565        rowSet = psArrayAlloc(3);
    493566        rowSet->n = 0;
    494         psArrayAdd(rowSet, 0, _get_row());
    495         psArrayAdd(rowSet, 0, _get_row());
    496         psArrayAdd(rowSet, 0, _get_row());
     567
     568        row = _get_row();
     569        psArrayAdd(rowSet, 0, row);
     570        psFree(row);
     571
     572        row = _get_row();
     573        psArrayAdd(rowSet, 0, row);
     574        psFree(row);
     575
     576        row = _get_row();
     577        psArrayAdd(rowSet, 0, row);
     578        psFree(row);
     579
    497580        failed = ! psDBInsertRows(dbh, table, rowSet);
    498581        if (!failed) {
    499             ary = psDBDumpRows(dbh, table);
    500             failed = (ary == NULL);
     582            where = _get_where();
     583            updates = _get_update_values("foobar", -1, 3.3333, 1234.5);
     584            failed = (psDBUpdateRows(dbh, table, where, updates) < 0);
     585            psFree(updates);
     586            psFree(where);
    501587        }
    502         psDBDropTable(dbh, table);
    503     }
    504 
    505     _cleanup_psDB(dbh);
    506 
    507     return failed;
    508 }
    509 
    510 // Testpoint #XXX, TPDBDumpCols shall dump all cols from a test table ...
    511 psS32 TPDBDumpCols( void )
    512 {
    513     psS32 failed = 0;
    514     psDB *dbh = NULL;
    515     const char* table = "table9";
    516     psMetadata *meta = NULL;
    517 
    518     dbh = _init_psDB();
    519     if (dbh == NULL) {
    520         return 1;
    521     }
    522 
    523     psLogMsg( __func__, PS_LOG_INFO, "psDBDumpCols shall dump all cols from a test table.\n" );
    524 
    525     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    526     if (!failed) {
    527         meta = psDBDumpCols(dbh, table);
    528         failed = (meta == NULL);
    529         psDBDropTable(dbh, table);
    530     }
    531 
    532     _cleanup_psDB(dbh);
    533 
    534     return failed;
    535 }
    536 
    537 // Testpoint #XXX, TPDBUpdateRows shall update rows in a test table ...
    538 psS32 TPDBUpdateRows( void )
     588        psFree(rowSet);
     589        psDBDropTable(dbh, table);
     590    }
     591
     592    psFree(md);
     593    psDBCleanup(dbh);
     594
     595    return failed;
     596}
     597
     598// Testpoint #XXX, TPDBDeleteRows shall update rows in a test table ...
     599psS32 TPDBDeleteRows( void )
    539600{
    540601    psS32 failed = 0;
    … …  
    542603    const char* table = "table10";
    543604    psArray *rowSet = NULL;
    544 
    545     dbh = _init_psDB();
    546     if (dbh == NULL) {
    547         return 1;
    548     }
    549 
    550     psLogMsg( __func__, PS_LOG_INFO, "psDBUpdateRows shall dump all rows from a test table.\n" );
    551 
    552     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    553     if (!failed) {
    554         rowSet = psArrayAlloc(1);
     605    psMetadata *where=NULL, *row=NULL, *md = _get_CreateTableMetadata();
     606
     607    dbh = _init_psDB();
     608    if (dbh == NULL) {
     609        return 1;
     610    }
     611
     612    psLogMsg( __func__, PS_LOG_INFO, "psDBDeleteRows shall delete rows from a test table.\n" );
     613
     614    failed = ! psDBCreateTable(dbh, table, md);
     615    if (!failed) {
     616        rowSet = psArrayAlloc(3);
    555617        rowSet->n = 0;
    556         psArrayAdd(rowSet, 0, _get_row());
    557         psArrayAdd(rowSet, 0, _get_row());
    558         psArrayAdd(rowSet, 0, _get_row());
     618
     619        row = _get_row();
     620        psArrayAdd(rowSet, 0, row);
     621        psFree(row);
     622
     623        row = _get_row();
     624        psArrayAdd(rowSet, 0, row);
     625        psFree(row);
     626
     627        row = _get_row();
     628        psArrayAdd(rowSet, 0, row);
     629        psFree(row);
     630
    559631        failed = ! psDBInsertRows(dbh, table, rowSet);
    560632        if (!failed) {
    561             failed = (psDBUpdateRows(dbh, table, _get_where(), _get_update_values(
    562                                          "foobar", -1, 3.3333, 1234.5)) < 0);
     633            where = _get_where();
     634            failed = (psDBDeleteRows(dbh, table, where) < 0);
     635            psFree(where);
    563636        }
    564         psDBDropTable(dbh, table);
    565     }
    566 
    567     _cleanup_psDB(dbh);
    568 
    569     return failed;
    570 }
    571 
    572 // Testpoint #XXX, TPDBDeleteRows shall update rows in a test table ...
    573 psS32 TPDBDeleteRows( void )
    574 {
    575     psS32 failed = 0;
    576     psDB *dbh = NULL;
    577     const char* table = "table10";
    578     psArray *rowSet = NULL;
    579 
    580     dbh = _init_psDB();
    581     if (dbh == NULL) {
    582         return 1;
    583     }
    584 
    585     psLogMsg( __func__, PS_LOG_INFO, "psDBDeleteRows shall delete rows from a test table.\n" );
    586 
    587     failed = ! psDBCreateTable(dbh, table, _get_CreateTableMetadata());
    588     if (!failed) {
    589         rowSet = psArrayAlloc(1);
    590         rowSet->n = 0;
    591         psArrayAdd(rowSet, 0, _get_row());
    592         psArrayAdd(rowSet, 0, _get_row());
    593         psArrayAdd(rowSet, 0, _get_row());
    594         failed = ! psDBInsertRows(dbh, table, rowSet);
    595         if (!failed) {
    596             failed = (psDBDeleteRows(dbh, table, _get_where()) < 0);
    597         }
    598         psDBDropTable(dbh, table);
    599     }
    600 
    601     _cleanup_psDB(dbh);
    602 
    603     return failed;
    604 }
    605 
     637        psFree(rowSet);
     638        psDBDropTable(dbh, table);
     639    }
     640
     641    psFree(md);
     642    psDBCleanup(dbh);
     643
     644    return failed;
     645}
     646
     647// Testpoint #XXX, psDBCreate shall create a new test database.
     648//psS32 TPDBCreate( void )
     649//{
     650//    const char *test_db = "ps_test_db";
     651//    psS32 failed = 0;
     652//    psDB *dbh = NULL;
     653//
     654//    dbh = _init_psDB();
     655//    if (dbh == NULL) {
     656//        return 1;
     657//    }
     658//
     659//    psLogMsg( __func__, PS_LOG_INFO, "psDBCreate shall create new new test database.\n" );
     660//
     661//    failed = ! psDBCreate(dbh, test_db);
     662//    if (!failed) {
     663//        psDBDrop(dbh, test_db);
     664//    }
     665//
     666//    psDBCleanup(dbh);
     667//
     668//    return failed;
     669//}
     670
     671// Testpoint #XXX, psDBDrop shall create a new test database.
     672//psS32 TPDBDrop( void )
     673//{
     674//    const char *test_db = "ps_test_db";
     675//    psS32 failed = 0;
     676//    psDB *dbh = NULL;
     677//
     678//    dbh = _init_psDB();
     679//    if (dbh == NULL) {
     680//        return 1;
     681//    }
     682//
     683//    psLogMsg( __func__, PS_LOG_INFO, "psDBDrop shall create/drop a new new test database.\n" );
     684//
     685//    failed = psDBCreate(dbh, test_db);
     686//    if (!failed) {
     687//        failed = ! psDBDrop(dbh, test_db);
     688//    }
     689//
     690//    psDBCleanup(dbh);
     691//
     692//    return failed;
     693//}
     694
Note: See TracChangeset for help on using the changeset viewer.