LCOV - code coverage report
Current view: top level - progs - get_record_test.cxx (source / functions) Coverage Total Hit
Test: coverage.info Lines: 0.0 % 94 0
Test Date: 2025-11-11 10:26:08 Functions: 0.0 % 11 0

            Line data    Source code
       1              : //
       2              : // get_record_test: test db_create_record(), db_get_record(), db_set_record(), etc
       3              : //
       4              : // Author: Konstantin Olchanski, 2017-OCT-11
       5              : //
       6              : 
       7              : #undef NDEBUG // midas required assert() to be always enabled
       8              : 
       9              : #include <assert.h>
      10              : 
      11              : #include "midas.h"
      12              : #include "msystem.h"
      13              : #include "history.h"
      14              : #include "mstrlcpy.h"
      15              : 
      16              : typedef struct {
      17              :    INT       ivalue;
      18              :    INT       iarray[2];
      19              :    char      svalue[20];
      20              :    char      sarray[2][32];
      21              : } test1_struct;
      22              : 
      23            0 : void print_test1(const test1_struct* s)
      24              : {
      25            0 :    printf("test1_struct: ivalue %d, iarray %d %d, svalue [%s], sarray [%s] [%s]\n", s->ivalue, s->iarray[0], s->iarray[1], s->svalue, s->sarray[0], s->sarray[1]);
      26            0 : }
      27              : 
      28              : #define test1_STR "\
      29              : ivalue = INT : 1\n\
      30              : iarray = INT[2] : \n\
      31              : [0] 1\n\
      32              : [1] 2\n\
      33              : svalue = STRING : [20] /Runinfo/Run number\n\
      34              : sarray = STRING[2] : \n\
      35              : [32] str1\n\
      36              : [32] str2\n\
      37              : "
      38              : 
      39            0 : void test1(HNDLE hDB, HNDLE hKey)
      40              : {
      41              :    int status;
      42            0 :    printf("test1!\n");
      43              : 
      44              :    HNDLE hh;
      45            0 :    db_find_key(hDB, hKey, "test1", &hh);
      46            0 :    if (hh) {
      47            0 :       printf("already exists, skipping!\n");
      48            0 :       return;
      49              :    }
      50            0 :    printf("create test1\n");
      51            0 :    status = db_create_record(hDB, hKey, "test1", test1_STR);
      52            0 :    printf("db_create_record status %d\n", status);
      53              : }
      54              : 
      55            0 : void test1a(HNDLE hDB, HNDLE hKey)
      56              : {
      57              :    int status;
      58            0 :    printf("test1a!\n");
      59              : 
      60            0 :    printf("check test1\n");
      61            0 :    status = db_check_record(hDB, hKey, "test1", test1_STR, TRUE);
      62            0 :    printf("db_check_record status %d\n", status);
      63            0 : }
      64              : 
      65            0 : void test1b(HNDLE hDB, HNDLE hKey)
      66              : {
      67              :    int status;
      68            0 :    printf("test1b!\n");
      69              : 
      70              :    test1_struct s;
      71              : 
      72              :    HNDLE hh;
      73            0 :    db_find_key(hDB, hKey, "test1", &hh);
      74              : 
      75            0 :    printf("get test1\n");
      76            0 :    int size = sizeof(s);
      77            0 :    status = db_get_record(hDB, hh, &s, &size, 0);
      78            0 :    printf("db_get_record status %d, size %d/%d\n", status, (int)sizeof(s), size);
      79            0 :    print_test1(&s);
      80            0 : }
      81              : 
      82            0 : void test1c(HNDLE hDB, HNDLE hKey)
      83              : {
      84              :    int status;
      85            0 :    printf("test1c - db_get_record1!\n");
      86              : 
      87              :    test1_struct s;
      88              : 
      89              :    HNDLE hh;
      90            0 :    db_find_key(hDB, hKey, "test1", &hh);
      91              : 
      92            0 :    printf("get test1\n");
      93            0 :    int size = sizeof(s);
      94            0 :    status = db_get_record1(hDB, hh, &s, &size, 0, test1_STR);
      95            0 :    printf("db_get_record1 status %d, size %d/%d\n", status, (int)sizeof(s), size);
      96            0 :    print_test1(&s);
      97            0 : }
      98              : 
      99            0 : void test1d(HNDLE hDB, HNDLE hKey)
     100              : {
     101              :    int status;
     102            0 :    printf("test1d - db_get_record2!\n");
     103              : 
     104              :    test1_struct s;
     105              : 
     106              :    HNDLE hh;
     107            0 :    db_find_key(hDB, hKey, "test1", &hh);
     108              : 
     109            0 :    printf("get test1\n");
     110            0 :    int size = sizeof(s);
     111            0 :    status = db_get_record2(hDB, hh, &s, &size, 0, test1_STR, 0);
     112            0 :    printf("db_get_record2 status %d, size %d/%d\n", status, (int)sizeof(s), size);
     113            0 :    print_test1(&s);
     114            0 : }
     115              : 
     116              : typedef struct {
     117              :    WORD      wvalue;
     118              :    DWORD     dwvalue;
     119              :    double    dvalue;
     120              :    char      cvalue;
     121              :    DWORD     dwvalue2;
     122              :    float     fvalue;
     123              :    double    dvalue2;
     124              :    char      cvalue2;
     125              :    char      svalue[10];
     126              :    double    dvalue3;
     127              : } test2_struct;
     128              : 
     129            0 : void print_test2(const test2_struct* s)
     130              : {
     131            0 :    printf("test2_struct: wvalue %d, dwvalue %d, dvalue %f, cvalue %d, dwvalue2 %d, fvalue %f, dvalue2 %f, cvalue2 %d, svalue [%s], dvalue3 %f\n", s->wvalue, s->dwvalue, s->dvalue, s->cvalue, s->dwvalue2, s->fvalue, s->dvalue2, s->cvalue2, s->svalue, s->dvalue3);
     132            0 : }
     133              : 
     134              : #define test2_STR "\
     135              : wvalue = WORD : 1\n\
     136              : dwvalue = DWORD : 2\n\
     137              : dvalue = DOUBLE : 3.3\n\
     138              : cvalue = CHAR : 4\n\
     139              : dwvalue2 = DWORD : 5\n\
     140              : fvalue = FLOAT : 6.6\n\
     141              : dvalue2 = DOUBLE : 7.7\n\
     142              : cvalue2 = CHAR : 8\n\
     143              : svalue = STRING : [10] 99999\n\
     144              : dvalue3 = DOUBLE : 10.01\n\
     145              : "
     146              : 
     147            0 : void test2(HNDLE hDB, HNDLE hKey)
     148              : {
     149              :    int status;
     150            0 :    printf("test2!\n");
     151              : 
     152              :    HNDLE hh;
     153            0 :    db_find_key(hDB, hKey, "test2", &hh);
     154            0 :    if (hh) {
     155            0 :       printf("already exists, skipping!\n");
     156            0 :       return;
     157              :    }
     158            0 :    printf("create test2\n");
     159            0 :    status = db_create_record(hDB, hKey, "test2", test2_STR);
     160            0 :    printf("db_create_record status %d\n", status);
     161              : }
     162              : 
     163            0 : void test2b(HNDLE hDB, HNDLE hKey)
     164              : {
     165              :    int status;
     166            0 :    printf("test2b!\n");
     167              : 
     168              :    test2_struct s;
     169              : 
     170              :    HNDLE hh;
     171            0 :    db_find_key(hDB, hKey, "test2", &hh);
     172              : 
     173            0 :    printf("get test2\n");
     174            0 :    int size = sizeof(s);
     175            0 :    status = db_get_record(hDB, hh, &s, &size, 0);
     176            0 :    printf("db_get_record status %d, size %d/%d\n", status, (int)sizeof(s), size);
     177            0 :    print_test2(&s);
     178            0 : }
     179              : 
     180            0 : void test2d(HNDLE hDB, HNDLE hKey)
     181              : {
     182              :    int status;
     183            0 :    printf("test2d - db_get_record2!\n");
     184              : 
     185              :    test2_struct s;
     186              : 
     187              :    HNDLE hh;
     188            0 :    db_find_key(hDB, hKey, "test2", &hh);
     189              : 
     190            0 :    printf("get test2\n");
     191            0 :    int size = sizeof(s);
     192            0 :    status = db_get_record2(hDB, hh, &s, &size, 0, test2_STR, 0);
     193            0 :    printf("db_get_record2 status %d, size %d/%d\n", status, (int)sizeof(s), size);
     194            0 :    print_test2(&s);
     195            0 : }
     196              : 
     197            0 : int main(int argc, char *argv[])
     198              : {
     199            0 :    int status = 0;
     200              :    HNDLE hDB;
     201              :    char host_name[256];
     202              :    char expt_name[256];
     203            0 :    host_name[0] = 0;
     204            0 :    expt_name[0] = 0;
     205              : 
     206            0 :    cm_get_environment(host_name, sizeof(host_name), expt_name, sizeof(expt_name));
     207              : 
     208            0 :    status = cm_connect_experiment1(host_name, expt_name, "get_record_test", 0, DEFAULT_ODB_SIZE, 0);
     209            0 :    assert(status == CM_SUCCESS);
     210              :    
     211            0 :    status = cm_get_experiment_database(&hDB, NULL);
     212            0 :    assert(status == CM_SUCCESS);
     213              : 
     214            0 :    HNDLE hKey = 0;
     215              : 
     216            0 :    test1(hDB, hKey);
     217              :    //test1a(hDB, hKey);
     218              :    //test1b(hDB, hKey);
     219            0 :    test1b(hDB, hKey);
     220            0 :    test1d(hDB, hKey);
     221              : 
     222            0 :    test2(hDB, hKey);
     223            0 :    test2b(hDB, hKey);
     224            0 :    test2d(hDB, hKey);
     225              : 
     226            0 :    status = cm_disconnect_experiment();
     227            0 :    assert(status == CM_SUCCESS);
     228              : 
     229            0 :    return 0;
     230              : }   
     231              : 
     232              : /* emacs
     233              :  * Local Variables:
     234              :  * tab-width: 8
     235              :  * c-basic-offset: 3
     236              :  * indent-tabs-mode: nil
     237              :  * End:
     238              :  */
        

Generated by: LCOV version 2.0-1