IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9684 for trunk/ippdb/tests


Ignore:
Timestamp:
Oct 20, 2006, 2:38:16 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.50

Location:
trunk/ippdb/tests
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/tests/alloc.c

    r9423 r9684  
    99{
    1010    {
    11         weatherRow      *object;
    12 
    13         object = weatherRowAlloc(32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32    );
    14 
    15         if (!object) {
    16             exit(EXIT_FAILURE);
    17         }
    18 
    19         if (!object->temp01 == 32.32) {
    20             psFree(object);
    21             exit(EXIT_FAILURE);
    22         }
    23         if (!object->humi01 == 32.32) {
    24             psFree(object);
    25             exit(EXIT_FAILURE);
    26         }
    27         if (!object->temp02 == 32.32) {
    28             psFree(object);
    29             exit(EXIT_FAILURE);
    30         }
    31         if (!object->humi02 == 32.32) {
    32             psFree(object);
    33             exit(EXIT_FAILURE);
    34         }
    35         if (!object->temp03 == 32.32) {
    36             psFree(object);
    37             exit(EXIT_FAILURE);
    38         }
    39         if (!object->humi03 == 32.32) {
    40             psFree(object);
    41             exit(EXIT_FAILURE);
    42         }
    43         if (!object->pressure == 32.32) {
    44             psFree(object);
    45             exit(EXIT_FAILURE);
    46         }
    47 
    48         psFree(object);
    49     }
    50 
    51     {
    52         skyp_transparencyRow *object;
    53 
    54         object = skyp_transparencyRowAlloc("a string", 64.64, -32, 64.64, 64.64, 32.32, 64.64    );
    55 
    56         if (!object) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
     11        summitExpRow    *object;
     12
     13        object = summitExpRowAlloc("a string", "a string", "a string", "a string", "a string"    );
     14
     15        if (!object) {
     16            exit(EXIT_FAILURE);
     17        }
     18
     19        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     20            psFree(object);
     21            exit(EXIT_FAILURE);
     22        }
     23        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     24            psFree(object);
     25            exit(EXIT_FAILURE);
     26        }
     27        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     28            psFree(object);
     29            exit(EXIT_FAILURE);
     30        }
     31        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     32            psFree(object);
     33            exit(EXIT_FAILURE);
     34        }
     35        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     36            psFree(object);
     37            exit(EXIT_FAILURE);
     38        }
     39
     40        psFree(object);
     41    }
     42
     43    {
     44        pzPendingExpRow *object;
     45
     46        object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32    );
     47
     48        if (!object) {
     49            exit(EXIT_FAILURE);
     50        }
     51
     52        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     53            psFree(object);
     54            exit(EXIT_FAILURE);
     55        }
     56        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     57            psFree(object);
     58            exit(EXIT_FAILURE);
     59        }
     60        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     61            psFree(object);
     62            exit(EXIT_FAILURE);
     63        }
     64        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     65            psFree(object);
     66            exit(EXIT_FAILURE);
     67        }
     68        if (!object->imfiles == -32) {
     69            psFree(object);
     70            exit(EXIT_FAILURE);
     71        }
     72
     73        psFree(object);
     74    }
     75
     76    {
     77        pzPendingImfileRow *object;
     78
     79        object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string"    );
     80
     81        if (!object) {
     82            exit(EXIT_FAILURE);
     83        }
     84
     85        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     86            psFree(object);
     87            exit(EXIT_FAILURE);
     88        }
     89        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     90            psFree(object);
     91            exit(EXIT_FAILURE);
     92        }
     93        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     94            psFree(object);
     95            exit(EXIT_FAILURE);
     96        }
     97        if (!object->bytes == -32) {
     98            psFree(object);
     99            exit(EXIT_FAILURE);
     100        }
     101        if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
     102            psFree(object);
     103            exit(EXIT_FAILURE);
     104        }
     105        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     106            psFree(object);
     107            exit(EXIT_FAILURE);
     108        }
     109        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     110            psFree(object);
     111            exit(EXIT_FAILURE);
     112        }
     113        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     114            psFree(object);
     115            exit(EXIT_FAILURE);
     116        }
     117
     118        psFree(object);
     119    }
     120
     121    {
     122        newExpRow       *object;
     123
     124        object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32    );
     125
     126        if (!object) {
     127            exit(EXIT_FAILURE);
     128        }
     129
     130        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     131            psFree(object);
     132            exit(EXIT_FAILURE);
     133        }
     134        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     135            psFree(object);
     136            exit(EXIT_FAILURE);
     137        }
     138        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     139            psFree(object);
     140            exit(EXIT_FAILURE);
     141        }
     142        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     143            psFree(object);
     144            exit(EXIT_FAILURE);
     145        }
     146        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     147            psFree(object);
     148            exit(EXIT_FAILURE);
     149        }
     150        if (!object->imfiles == -32) {
     151            psFree(object);
     152            exit(EXIT_FAILURE);
     153        }
     154
     155        psFree(object);
     156    }
     157
     158    {
     159        newImfileRow    *object;
     160
     161        object = newImfileRowAlloc("a string", "a string", "a string", "a string"    );
     162
     163        if (!object) {
     164            exit(EXIT_FAILURE);
     165        }
     166
     167        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     168            psFree(object);
     169            exit(EXIT_FAILURE);
     170        }
     171        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     172            psFree(object);
     173            exit(EXIT_FAILURE);
     174        }
     175        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     176            psFree(object);
     177            exit(EXIT_FAILURE);
     178        }
     179        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     180            psFree(object);
     181            exit(EXIT_FAILURE);
     182        }
     183
     184        psFree(object);
     185    }
     186
     187    {
     188        rawDetrendExpRow *object;
     189
     190        object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z"    );
     191
     192        if (!object) {
     193            exit(EXIT_FAILURE);
     194        }
     195
     196        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     197            psFree(object);
     198            exit(EXIT_FAILURE);
     199        }
     200        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     201            psFree(object);
     202            exit(EXIT_FAILURE);
     203        }
     204        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     205            psFree(object);
     206            exit(EXIT_FAILURE);
     207        }
     208        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     209            psFree(object);
     210            exit(EXIT_FAILURE);
     211        }
     212        if (!object->imfiles == -32) {
     213            psFree(object);
     214            exit(EXIT_FAILURE);
     215        }
    60216        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    61217            psFree(object);
    62218            exit(EXIT_FAILURE);
    63219        }
    64         if (!object->trans == 64.64) {
    65             psFree(object);
    66             exit(EXIT_FAILURE);
    67         }
    68         if (!object->nstars == -32) {
     220        if (!object->airmass == 32.32) {
    69221            psFree(object);
    70222            exit(EXIT_FAILURE);
    … …  
    78230            exit(EXIT_FAILURE);
    79231        }
    80         if (!object->exptime == 32.32) {
    81             psFree(object);
    82             exit(EXIT_FAILURE);
    83         }
    84         if (!object->sky_bright == 64.64) {
    85             psFree(object);
    86             exit(EXIT_FAILURE);
    87         }
    88 
    89         psFree(object);
    90     }
    91 
    92     {
    93         skyp_absorptionRow *object;
    94 
    95         object = skyp_absorptionRowAlloc("a string", 32.32, 32.32, 32.32, -32, 64.64, 64.64, 32.32, 64.64    );
    96 
    97         if (!object) {
    98             exit(EXIT_FAILURE);
    99         }
    100 
    101         if (strncmp(object->disperser_id, "a string", MAX_STRING_LENGTH)) {
    102             psFree(object);
    103             exit(EXIT_FAILURE);
    104         }
    105         if (!object->atmcomp1 == 32.32) {
    106             psFree(object);
    107             exit(EXIT_FAILURE);
    108         }
    109         if (!object->atmcomp2 == 32.32) {
    110             psFree(object);
    111             exit(EXIT_FAILURE);
    112         }
    113         if (!object->atmcomp3 == 32.32) {
    114             psFree(object);
    115             exit(EXIT_FAILURE);
    116         }
    117         if (!object->nstars == -32) {
     232        if (!object->exp_time == 32.32) {
     233            psFree(object);
     234            exit(EXIT_FAILURE);
     235        }
     236        if (!object->bg == 64.64) {
     237            psFree(object);
     238            exit(EXIT_FAILURE);
     239        }
     240        if (!object->bg_stdev == 64.64) {
     241            psFree(object);
     242            exit(EXIT_FAILURE);
     243        }
     244        if (!object->bg_mean_stdev == 64.64) {
     245            psFree(object);
     246            exit(EXIT_FAILURE);
     247        }
     248        if (!object->alt == 64.64) {
     249            psFree(object);
     250            exit(EXIT_FAILURE);
     251        }
     252        if (!object->az == 64.64) {
     253            psFree(object);
     254            exit(EXIT_FAILURE);
     255        }
     256        if (!object->ccd_temp == 32.32) {
     257            psFree(object);
     258            exit(EXIT_FAILURE);
     259        }
     260        if (!object->posang == 64.64) {
     261            psFree(object);
     262            exit(EXIT_FAILURE);
     263        }
     264        if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
     265            psFree(object);
     266            exit(EXIT_FAILURE);
     267        }
     268            psFree(object);
     269            exit(EXIT_FAILURE);
     270        }
     271
     272        psFree(object);
     273    }
     274
     275    {
     276        rawScienceExpRow *object;
     277
     278        object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z"    );
     279
     280        if (!object) {
     281            exit(EXIT_FAILURE);
     282        }
     283
     284        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     285            psFree(object);
     286            exit(EXIT_FAILURE);
     287        }
     288        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     289            psFree(object);
     290            exit(EXIT_FAILURE);
     291        }
     292        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     293            psFree(object);
     294            exit(EXIT_FAILURE);
     295        }
     296        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     297            psFree(object);
     298            exit(EXIT_FAILURE);
     299        }
     300        if (!object->imfiles == -32) {
     301            psFree(object);
     302            exit(EXIT_FAILURE);
     303        }
     304        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     305            psFree(object);
     306            exit(EXIT_FAILURE);
     307        }
     308        if (!object->airmass == 32.32) {
    118309            psFree(object);
    119310            exit(EXIT_FAILURE);
    … …  
    127318            exit(EXIT_FAILURE);
    128319        }
    129         if (!object->exptime == 32.32) {
    130             psFree(object);
    131             exit(EXIT_FAILURE);
    132         }
    133         if (!object->sky_bright == 64.64) {
    134             psFree(object);
    135             exit(EXIT_FAILURE);
    136         }
    137 
    138         psFree(object);
    139     }
    140 
    141     {
    142         skyp_emissionRow *object;
    143 
    144         object = skyp_emissionRowAlloc("a string", 32.32, 32.32, 32.32, 32.32, 32.32    );
    145 
    146         if (!object) {
    147             exit(EXIT_FAILURE);
    148         }
    149 
    150         if (strncmp(object->disperser_id, "a string", MAX_STRING_LENGTH)) {
    151             psFree(object);
    152             exit(EXIT_FAILURE);
    153         }
    154         if (!object->atmcomp1 == 32.32) {
    155             psFree(object);
    156             exit(EXIT_FAILURE);
    157         }
    158         if (!object->atmcomp2 == 32.32) {
    159             psFree(object);
    160             exit(EXIT_FAILURE);
    161         }
    162         if (!object->atmcomp3 == 32.32) {
    163             psFree(object);
    164             exit(EXIT_FAILURE);
    165         }
    166         if (!object->continuum == 32.32) {
    167             psFree(object);
    168             exit(EXIT_FAILURE);
    169         }
    170         if (!object->exptime == 32.32) {
    171             psFree(object);
    172             exit(EXIT_FAILURE);
    173         }
    174 
    175         psFree(object);
    176     }
    177 
    178     {
    179         dimmRow         *object;
    180 
    181         object = dimmRowAlloc(32.32, 32.32, 32.32, 64.64, 64.64, 32.32, "a string"    );
    182 
    183         if (!object) {
    184             exit(EXIT_FAILURE);
    185         }
    186 
    187         if (!object->sigmax == 32.32) {
    188             psFree(object);
    189             exit(EXIT_FAILURE);
    190         }
    191         if (!object->sigmay == 32.32) {
    192             psFree(object);
    193             exit(EXIT_FAILURE);
    194         }
    195         if (!object->fwhm == 32.32) {
     320        if (!object->exp_time == 32.32) {
     321            psFree(object);
     322            exit(EXIT_FAILURE);
     323        }
     324        if (!object->bg == 64.64) {
     325            psFree(object);
     326            exit(EXIT_FAILURE);
     327        }
     328        if (!object->bg_stdev == 64.64) {
     329            psFree(object);
     330            exit(EXIT_FAILURE);
     331        }
     332        if (!object->bg_mean_stdev == 64.64) {
     333            psFree(object);
     334            exit(EXIT_FAILURE);
     335        }
     336        if (!object->alt == 64.64) {
     337            psFree(object);
     338            exit(EXIT_FAILURE);
     339        }
     340        if (!object->az == 64.64) {
     341            psFree(object);
     342            exit(EXIT_FAILURE);
     343        }
     344        if (!object->ccd_temp == 32.32) {
     345            psFree(object);
     346            exit(EXIT_FAILURE);
     347        }
     348        if (!object->posang == 64.64) {
     349            psFree(object);
     350            exit(EXIT_FAILURE);
     351        }
     352        if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
     353            psFree(object);
     354            exit(EXIT_FAILURE);
     355        }
     356            psFree(object);
     357            exit(EXIT_FAILURE);
     358        }
     359
     360        psFree(object);
     361    }
     362
     363    {
     364        rawImfileRow    *object;
     365
     366        object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z"    );
     367
     368        if (!object) {
     369            exit(EXIT_FAILURE);
     370        }
     371
     372        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     373            psFree(object);
     374            exit(EXIT_FAILURE);
     375        }
     376        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     377            psFree(object);
     378            exit(EXIT_FAILURE);
     379        }
     380        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     381            psFree(object);
     382            exit(EXIT_FAILURE);
     383        }
     384        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     385            psFree(object);
     386            exit(EXIT_FAILURE);
     387        }
     388        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     389            psFree(object);
     390            exit(EXIT_FAILURE);
     391        }
     392        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     393            psFree(object);
     394            exit(EXIT_FAILURE);
     395        }
     396        if (!object->airmass == 32.32) {
    196397            psFree(object);
    197398            exit(EXIT_FAILURE);
    … …  
    205406            exit(EXIT_FAILURE);
    206407        }
    207         if (!object->expttime == 32.32) {
    208             psFree(object);
    209             exit(EXIT_FAILURE);
    210         }
    211         if (strncmp(object->telescope_id, "a string", MAX_STRING_LENGTH)) {
    212             psFree(object);
    213             exit(EXIT_FAILURE);
    214         }
    215 
    216         psFree(object);
    217     }
    218 
    219     {
    220         skyp_irRow      *object;
    221 
    222         object = skyp_irRowAlloc(64.64, 64.64, 64.64, 64.64, 32.32, 32.32    );
    223 
    224         if (!object) {
    225             exit(EXIT_FAILURE);
    226         }
    227 
    228         if (!object->sky_bright == 64.64) {
    229             psFree(object);
    230             exit(EXIT_FAILURE);
    231         }
    232         if (!object->sky_var == 64.64) {
    233             psFree(object);
    234             exit(EXIT_FAILURE);
    235         }
    236         if (!object->ra == 64.64) {
    237             psFree(object);
    238             exit(EXIT_FAILURE);
    239         }
    240         if (!object->decl == 64.64) {
    241             psFree(object);
    242             exit(EXIT_FAILURE);
    243         }
    244         if (!object->fov_x == 32.32) {
    245             psFree(object);
    246             exit(EXIT_FAILURE);
    247         }
    248         if (!object->fov_y == 32.32) {
    249             psFree(object);
    250             exit(EXIT_FAILURE);
    251         }
    252 
    253         psFree(object);
    254     }
    255 
    256     {
    257         domeRow         *object;
    258 
    259         object = domeRowAlloc(32.32, true, true, true    );
    260 
    261         if (!object) {
    262             exit(EXIT_FAILURE);
    263         }
    264 
    265         if (!object->az == 32.32) {
    266             psFree(object);
    267             exit(EXIT_FAILURE);
    268         }
    269         if (!object->open == true) {
    270             psFree(object);
    271             exit(EXIT_FAILURE);
    272         }
    273         if (!object->light == true) {
    274             psFree(object);
    275             exit(EXIT_FAILURE);
    276         }
    277         if (!object->track == true) {
    278             psFree(object);
    279             exit(EXIT_FAILURE);
    280         }
    281 
    282         psFree(object);
    283     }
    284 
    285     {
    286         telescopeRow    *object;
    287 
    288         object = telescopeRowAlloc("a string", 32.32, 32.32, 64.64, 64.64    );
    289 
    290         if (!object) {
    291             exit(EXIT_FAILURE);
    292         }
    293 
    294         if (strncmp(object->guide, "a string", MAX_STRING_LENGTH)) {
    295             psFree(object);
    296             exit(EXIT_FAILURE);
    297         }
    298         if (!object->alt == 32.32) {
    299             psFree(object);
    300             exit(EXIT_FAILURE);
    301         }
    302         if (!object->az == 32.32) {
    303             psFree(object);
    304             exit(EXIT_FAILURE);
    305         }
    306         if (!object->ra == 64.64) {
    307             psFree(object);
    308             exit(EXIT_FAILURE);
    309         }
    310         if (!object->decl == 64.64) {
    311             psFree(object);
    312             exit(EXIT_FAILURE);
    313         }
    314 
    315         psFree(object);
    316     }
    317 
    318     {
    319         summitExpRow    *object;
    320 
    321         object = summitExpRowAlloc("a string", "a string", "a string", "a string", "a string"    );
    322 
    323         if (!object) {
    324             exit(EXIT_FAILURE);
    325         }
    326 
    327         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    328             psFree(object);
    329             exit(EXIT_FAILURE);
    330         }
    331         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    332             psFree(object);
    333             exit(EXIT_FAILURE);
    334         }
    335         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    336             psFree(object);
    337             exit(EXIT_FAILURE);
    338         }
    339         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    340             psFree(object);
    341             exit(EXIT_FAILURE);
    342         }
    343         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    344             psFree(object);
    345             exit(EXIT_FAILURE);
    346         }
    347 
    348         psFree(object);
    349     }
    350 
    351     {
    352         pzPendingExpRow *object;
    353 
    354         object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32    );
    355 
    356         if (!object) {
    357             exit(EXIT_FAILURE);
    358         }
    359 
    360         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    361             psFree(object);
    362             exit(EXIT_FAILURE);
    363         }
    364         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    365             psFree(object);
    366             exit(EXIT_FAILURE);
    367         }
    368         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    369             psFree(object);
    370             exit(EXIT_FAILURE);
    371         }
    372         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    373             psFree(object);
    374             exit(EXIT_FAILURE);
    375         }
    376         if (!object->imfiles == -32) {
    377             psFree(object);
    378             exit(EXIT_FAILURE);
    379         }
    380 
    381         psFree(object);
    382     }
    383 
    384     {
    385         pzPendingImfileRow *object;
    386 
    387         object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string"    );
    388 
    389         if (!object) {
    390             exit(EXIT_FAILURE);
    391         }
    392 
    393         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    394             psFree(object);
    395             exit(EXIT_FAILURE);
    396         }
    397         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    398             psFree(object);
    399             exit(EXIT_FAILURE);
    400         }
    401         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    402             psFree(object);
    403             exit(EXIT_FAILURE);
    404         }
    405         if (!object->bytes == -32) {
    406             psFree(object);
    407             exit(EXIT_FAILURE);
    408         }
    409         if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
    410             psFree(object);
    411             exit(EXIT_FAILURE);
    412         }
    413         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    414             psFree(object);
    415             exit(EXIT_FAILURE);
    416         }
    417         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    418             psFree(object);
    419             exit(EXIT_FAILURE);
    420         }
    421         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    422             psFree(object);
    423             exit(EXIT_FAILURE);
    424         }
    425 
    426         psFree(object);
    427     }
    428 
    429     {
    430         newExpRow       *object;
    431 
    432         object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32    );
    433 
    434         if (!object) {
    435             exit(EXIT_FAILURE);
    436         }
    437 
    438         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    439             psFree(object);
    440             exit(EXIT_FAILURE);
    441         }
    442         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    443             psFree(object);
    444             exit(EXIT_FAILURE);
    445         }
    446         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    447             psFree(object);
    448             exit(EXIT_FAILURE);
    449         }
    450         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    451             psFree(object);
    452             exit(EXIT_FAILURE);
    453         }
    454         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    455             psFree(object);
    456             exit(EXIT_FAILURE);
    457         }
    458         if (!object->imfiles == -32) {
    459             psFree(object);
    460             exit(EXIT_FAILURE);
    461         }
    462 
    463         psFree(object);
    464     }
    465 
    466     {
    467         newImfileRow    *object;
    468 
    469         object = newImfileRowAlloc("a string", "a string", "a string", "a string"    );
    470 
    471         if (!object) {
    472             exit(EXIT_FAILURE);
    473         }
    474 
    475         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    476             psFree(object);
    477             exit(EXIT_FAILURE);
    478         }
    479         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    480             psFree(object);
    481             exit(EXIT_FAILURE);
    482         }
    483         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    484             psFree(object);
    485             exit(EXIT_FAILURE);
    486         }
    487         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    488             psFree(object);
    489             exit(EXIT_FAILURE);
    490         }
    491 
    492         psFree(object);
    493     }
    494 
    495     {
    496         rawDetrendExpRow *object;
    497 
    498         object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string"    );
    499 
    500         if (!object) {
    501             exit(EXIT_FAILURE);
    502         }
    503 
    504         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    505             psFree(object);
    506             exit(EXIT_FAILURE);
    507         }
    508         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    509             psFree(object);
    510             exit(EXIT_FAILURE);
    511         }
    512         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    513             psFree(object);
    514             exit(EXIT_FAILURE);
    515         }
    516         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    517             psFree(object);
    518             exit(EXIT_FAILURE);
    519         }
    520         if (!object->imfiles == -32) {
    521             psFree(object);
    522             exit(EXIT_FAILURE);
    523         }
    524         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    525             psFree(object);
    526             exit(EXIT_FAILURE);
    527         }
    528         if (!object->airmass == 32.32) {
    529             psFree(object);
    530             exit(EXIT_FAILURE);
    531         }
    532         if (!object->ra == 64.64) {
    533             psFree(object);
    534             exit(EXIT_FAILURE);
    535         }
    536         if (!object->decl == 64.64) {
    537             psFree(object);
    538             exit(EXIT_FAILURE);
    539         }
    540408        if (!object->exp_time == 32.32) {
    541409            psFree(object);
    … …  
    574442            exit(EXIT_FAILURE);
    575443        }
    576 
    577         psFree(object);
    578     }
    579 
    580     {
    581         rawScienceExpRow *object;
    582 
    583         object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string"    );
    584 
    585         if (!object) {
    586             exit(EXIT_FAILURE);
    587         }
    588 
    589         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    590             psFree(object);
    591             exit(EXIT_FAILURE);
    592         }
    593         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    594             psFree(object);
    595             exit(EXIT_FAILURE);
    596         }
    597         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    598             psFree(object);
    599             exit(EXIT_FAILURE);
    600         }
    601         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    602             psFree(object);
    603             exit(EXIT_FAILURE);
    604         }
    605         if (!object->imfiles == -32) {
    606             psFree(object);
    607             exit(EXIT_FAILURE);
    608         }
    609         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    610             psFree(object);
    611             exit(EXIT_FAILURE);
    612         }
    613         if (!object->airmass == 32.32) {
    614             psFree(object);
    615             exit(EXIT_FAILURE);
    616         }
    617         if (!object->ra == 64.64) {
    618             psFree(object);
    619             exit(EXIT_FAILURE);
    620         }
    621         if (!object->decl == 64.64) {
    622             psFree(object);
    623             exit(EXIT_FAILURE);
    624         }
    625         if (!object->exp_time == 32.32) {
    626             psFree(object);
    627             exit(EXIT_FAILURE);
    628         }
    629         if (!object->bg == 64.64) {
    630             psFree(object);
    631             exit(EXIT_FAILURE);
    632         }
    633         if (!object->bg_stdev == 64.64) {
    634             psFree(object);
    635             exit(EXIT_FAILURE);
    636         }
    637         if (!object->bg_mean_stdev == 64.64) {
    638             psFree(object);
    639             exit(EXIT_FAILURE);
    640         }
    641         if (!object->alt == 64.64) {
    642             psFree(object);
    643             exit(EXIT_FAILURE);
    644         }
    645         if (!object->az == 64.64) {
    646             psFree(object);
    647             exit(EXIT_FAILURE);
    648         }
    649         if (!object->ccd_temp == 32.32) {
    650             psFree(object);
    651             exit(EXIT_FAILURE);
    652         }
    653         if (!object->posang == 64.64) {
    654             psFree(object);
    655             exit(EXIT_FAILURE);
    656         }
    657         if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
    658             psFree(object);
    659             exit(EXIT_FAILURE);
    660         }
    661 
    662         psFree(object);
    663     }
    664 
    665     {
    666         rawImfileRow    *object;
    667 
    668         object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string"    );
    669 
    670         if (!object) {
    671             exit(EXIT_FAILURE);
    672         }
    673 
    674         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    675             psFree(object);
    676             exit(EXIT_FAILURE);
    677         }
    678         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    679             psFree(object);
    680             exit(EXIT_FAILURE);
    681         }
    682         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    683             psFree(object);
    684             exit(EXIT_FAILURE);
    685         }
    686         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    687             psFree(object);
    688             exit(EXIT_FAILURE);
    689         }
    690         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    691             psFree(object);
    692             exit(EXIT_FAILURE);
    693         }
    694         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    695             psFree(object);
    696             exit(EXIT_FAILURE);
    697         }
    698         if (!object->airmass == 32.32) {
    699             psFree(object);
    700             exit(EXIT_FAILURE);
    701         }
    702         if (!object->ra == 64.64) {
    703             psFree(object);
    704             exit(EXIT_FAILURE);
    705         }
    706         if (!object->decl == 64.64) {
    707             psFree(object);
    708             exit(EXIT_FAILURE);
    709         }
    710         if (!object->exp_time == 32.32) {
    711             psFree(object);
    712             exit(EXIT_FAILURE);
    713         }
    714         if (!object->bg == 64.64) {
    715             psFree(object);
    716             exit(EXIT_FAILURE);
    717         }
    718         if (!object->bg_stdev == 64.64) {
    719             psFree(object);
    720             exit(EXIT_FAILURE);
    721         }
    722         if (!object->bg_mean_stdev == 64.64) {
    723             psFree(object);
    724             exit(EXIT_FAILURE);
    725         }
    726         if (!object->alt == 64.64) {
    727             psFree(object);
    728             exit(EXIT_FAILURE);
    729         }
    730         if (!object->az == 64.64) {
    731             psFree(object);
    732             exit(EXIT_FAILURE);
    733         }
    734         if (!object->ccd_temp == 32.32) {
    735             psFree(object);
    736             exit(EXIT_FAILURE);
    737         }
    738         if (!object->posang == 64.64) {
    739             psFree(object);
    740             exit(EXIT_FAILURE);
    741         }
    742         if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
    743444            psFree(object);
    744445            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/createtable.c

    r9301 r9684  
    1313        }
    1414
    15         if(!weatherCreateTable(dbh)) {
    16             exit(EXIT_FAILURE);
    17         }
    18 
    19         psDBCleanup(dbh);
    20     }
    21 
    22     {
    23         psDB            *dbh;
    24 
    25         dbh = psDBInit("localhost", "test", NULL, "test");
    26         if (!dbh) {
    27             exit(EXIT_FAILURE);
    28         }
    29 
    30         if(!skyp_transparencyCreateTable(dbh)) {
    31             exit(EXIT_FAILURE);
    32         }
    33 
    34         psDBCleanup(dbh);
    35     }
    36 
    37     {
    38         psDB            *dbh;
    39 
    40         dbh = psDBInit("localhost", "test", NULL, "test");
    41         if (!dbh) {
    42             exit(EXIT_FAILURE);
    43         }
    44 
    45         if(!skyp_absorptionCreateTable(dbh)) {
    46             exit(EXIT_FAILURE);
    47         }
    48 
    49         psDBCleanup(dbh);
    50     }
    51 
    52     {
    53         psDB            *dbh;
    54 
    55         dbh = psDBInit("localhost", "test", NULL, "test");
    56         if (!dbh) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
    60         if(!skyp_emissionCreateTable(dbh)) {
    61             exit(EXIT_FAILURE);
    62         }
    63 
    64         psDBCleanup(dbh);
    65     }
    66 
    67     {
    68         psDB            *dbh;
    69 
    70         dbh = psDBInit("localhost", "test", NULL, "test");
    71         if (!dbh) {
    72             exit(EXIT_FAILURE);
    73         }
    74 
    75         if(!dimmCreateTable(dbh)) {
    76             exit(EXIT_FAILURE);
    77         }
    78 
    79         psDBCleanup(dbh);
    80     }
    81 
    82     {
    83         psDB            *dbh;
    84 
    85         dbh = psDBInit("localhost", "test", NULL, "test");
    86         if (!dbh) {
    87             exit(EXIT_FAILURE);
    88         }
    89 
    90         if(!skyp_irCreateTable(dbh)) {
    91             exit(EXIT_FAILURE);
    92         }
    93 
    94         psDBCleanup(dbh);
    95     }
    96 
    97     {
    98         psDB            *dbh;
    99 
    100         dbh = psDBInit("localhost", "test", NULL, "test");
    101         if (!dbh) {
    102             exit(EXIT_FAILURE);
    103         }
    104 
    105         if(!domeCreateTable(dbh)) {
    106             exit(EXIT_FAILURE);
    107         }
    108 
    109         psDBCleanup(dbh);
    110     }
    111 
    112     {
    113         psDB            *dbh;
    114 
    115         dbh = psDBInit("localhost", "test", NULL, "test");
    116         if (!dbh) {
    117             exit(EXIT_FAILURE);
    118         }
    119 
    120         if(!telescopeCreateTable(dbh)) {
    121             exit(EXIT_FAILURE);
    122         }
    123 
    124         psDBCleanup(dbh);
    125     }
    126 
    127     {
    128         psDB            *dbh;
    129 
    130         dbh = psDBInit("localhost", "test", NULL, "test");
    131         if (!dbh) {
    132             exit(EXIT_FAILURE);
    133         }
    134 
    13515        if(!summitExpCreateTable(dbh)) {
    13616            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/dbcleanup.c

    r9301 r9684  
    1111    }
    1212
    13     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS weather");
    14     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_transparency");
    15     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_absorption");
    16     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_emission");
    17     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS dimm");
    18     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_ir");
    19     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS dome");
    20     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS telescope");
    2113    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp");
    2214    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingExp");

  • trunk/ippdb/tests/dbsetup.c

    r9301 r9684  
    1313
    1414    // remove the table if it already exists
    15     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS weather");
    16     weatherCreateTable(dbh);
    17 
    18     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_transparency");
    19     skyp_transparencyCreateTable(dbh);
    20 
    21     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_absorption");
    22     skyp_absorptionCreateTable(dbh);
    23 
    24     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_emission");
    25     skyp_emissionCreateTable(dbh);
    26 
    27     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS dimm");
    28     dimmCreateTable(dbh);
    29 
    30     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyp_ir");
    31     skyp_irCreateTable(dbh);
    32 
    33     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS dome");
    34     domeCreateTable(dbh);
    35 
    36     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS telescope");
    37     telescopeCreateTable(dbh);
    38 
    3915    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp");
    4016    summitExpCreateTable(dbh);

  • trunk/ippdb/tests/droptable.c

    r9301 r9684  
    1313        }
    1414
    15         if (!weatherDropTable(dbh)) {
    16             exit(EXIT_FAILURE);
    17         }
    18 
    19         psDBCleanup(dbh);
    20     }
    21 
    22     {
    23         psDB            *dbh;
    24 
    25         dbh = psDBInit("localhost", "test", NULL, "test");
    26         if (!dbh) {
    27             exit(EXIT_FAILURE);
    28         }
    29 
    30         if (!skyp_transparencyDropTable(dbh)) {
    31             exit(EXIT_FAILURE);
    32         }
    33 
    34         psDBCleanup(dbh);
    35     }
    36 
    37     {
    38         psDB            *dbh;
    39 
    40         dbh = psDBInit("localhost", "test", NULL, "test");
    41         if (!dbh) {
    42             exit(EXIT_FAILURE);
    43         }
    44 
    45         if (!skyp_absorptionDropTable(dbh)) {
    46             exit(EXIT_FAILURE);
    47         }
    48 
    49         psDBCleanup(dbh);
    50     }
    51 
    52     {
    53         psDB            *dbh;
    54 
    55         dbh = psDBInit("localhost", "test", NULL, "test");
    56         if (!dbh) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
    60         if (!skyp_emissionDropTable(dbh)) {
    61             exit(EXIT_FAILURE);
    62         }
    63 
    64         psDBCleanup(dbh);
    65     }
    66 
    67     {
    68         psDB            *dbh;
    69 
    70         dbh = psDBInit("localhost", "test", NULL, "test");
    71         if (!dbh) {
    72             exit(EXIT_FAILURE);
    73         }
    74 
    75         if (!dimmDropTable(dbh)) {
    76             exit(EXIT_FAILURE);
    77         }
    78 
    79         psDBCleanup(dbh);
    80     }
    81 
    82     {
    83         psDB            *dbh;
    84 
    85         dbh = psDBInit("localhost", "test", NULL, "test");
    86         if (!dbh) {
    87             exit(EXIT_FAILURE);
    88         }
    89 
    90         if (!skyp_irDropTable(dbh)) {
    91             exit(EXIT_FAILURE);
    92         }
    93 
    94         psDBCleanup(dbh);
    95     }
    96 
    97     {
    98         psDB            *dbh;
    99 
    100         dbh = psDBInit("localhost", "test", NULL, "test");
    101         if (!dbh) {
    102             exit(EXIT_FAILURE);
    103         }
    104 
    105         if (!domeDropTable(dbh)) {
    106             exit(EXIT_FAILURE);
    107         }
    108 
    109         psDBCleanup(dbh);
    110     }
    111 
    112     {
    113         psDB            *dbh;
    114 
    115         dbh = psDBInit("localhost", "test", NULL, "test");
    116         if (!dbh) {
    117             exit(EXIT_FAILURE);
    118         }
    119 
    120         if (!telescopeDropTable(dbh)) {
    121             exit(EXIT_FAILURE);
    122         }
    123 
    124         psDBCleanup(dbh);
    125     }
    126 
    127     {
    128         psDB            *dbh;
    129 
    130         dbh = psDBInit("localhost", "test", NULL, "test");
    131         if (!dbh) {
    132             exit(EXIT_FAILURE);
    133         }
    134 
    13515        if (!summitExpDropTable(dbh)) {
    13616            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/insert.c

    r9423 r9684  
    1313        }
    1414
    15         if (!weatherInsert(dbh, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32)) {
    16             exit(EXIT_FAILURE);
    17         }
    18 
    19         psDBCleanup(dbh);
    20     }
    21 
    22     {
    23         psDB            *dbh;
    24 
    25         dbh = psDBInit("localhost", "test", NULL, "test");
    26         if (!dbh) {
    27             exit(EXIT_FAILURE);
    28         }
    29 
    30         if (!skyp_transparencyInsert(dbh, "a string", 64.64, -32, 64.64, 64.64, 32.32, 64.64)) {
    31             exit(EXIT_FAILURE);
    32         }
    33 
    34         psDBCleanup(dbh);
    35     }
    36 
    37     {
    38         psDB            *dbh;
    39 
    40         dbh = psDBInit("localhost", "test", NULL, "test");
    41         if (!dbh) {
    42             exit(EXIT_FAILURE);
    43         }
    44 
    45         if (!skyp_absorptionInsert(dbh, "a string", 32.32, 32.32, 32.32, -32, 64.64, 64.64, 32.32, 64.64)) {
    46             exit(EXIT_FAILURE);
    47         }
    48 
    49         psDBCleanup(dbh);
    50     }
    51 
    52     {
    53         psDB            *dbh;
    54 
    55         dbh = psDBInit("localhost", "test", NULL, "test");
    56         if (!dbh) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
    60         if (!skyp_emissionInsert(dbh, "a string", 32.32, 32.32, 32.32, 32.32, 32.32)) {
    61             exit(EXIT_FAILURE);
    62         }
    63 
    64         psDBCleanup(dbh);
    65     }
    66 
    67     {
    68         psDB            *dbh;
    69 
    70         dbh = psDBInit("localhost", "test", NULL, "test");
    71         if (!dbh) {
    72             exit(EXIT_FAILURE);
    73         }
    74 
    75         if (!dimmInsert(dbh, 32.32, 32.32, 32.32, 64.64, 64.64, 32.32, "a string")) {
    76             exit(EXIT_FAILURE);
    77         }
    78 
    79         psDBCleanup(dbh);
    80     }
    81 
    82     {
    83         psDB            *dbh;
    84 
    85         dbh = psDBInit("localhost", "test", NULL, "test");
    86         if (!dbh) {
    87             exit(EXIT_FAILURE);
    88         }
    89 
    90         if (!skyp_irInsert(dbh, 64.64, 64.64, 64.64, 64.64, 32.32, 32.32)) {
    91             exit(EXIT_FAILURE);
    92         }
    93 
    94         psDBCleanup(dbh);
    95     }
    96 
    97     {
    98         psDB            *dbh;
    99 
    100         dbh = psDBInit("localhost", "test", NULL, "test");
    101         if (!dbh) {
    102             exit(EXIT_FAILURE);
    103         }
    104 
    105         if (!domeInsert(dbh, 32.32, true, true, true)) {
    106             exit(EXIT_FAILURE);
    107         }
    108 
    109         psDBCleanup(dbh);
    110     }
    111 
    112     {
    113         psDB            *dbh;
    114 
    115         dbh = psDBInit("localhost", "test", NULL, "test");
    116         if (!dbh) {
    117             exit(EXIT_FAILURE);
    118         }
    119 
    120         if (!telescopeInsert(dbh, "a string", 32.32, 32.32, 64.64, 64.64)) {
    121             exit(EXIT_FAILURE);
    122         }
    123 
    124         psDBCleanup(dbh);
    125     }
    126 
    127     {
    128         psDB            *dbh;
    129 
    130         dbh = psDBInit("localhost", "test", NULL, "test");
    131         if (!dbh) {
    132             exit(EXIT_FAILURE);
    133         }
    134 
    13515        if (!summitExpInsert(dbh, "a string", "a string", "a string", "a string", "a string")) {
    13616            exit(EXIT_FAILURE);
    … …  
    20888        }
    20989
    210         if (!rawDetrendExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string")) {
    211             exit(EXIT_FAILURE);
    212         }
    213 
    214         psDBCleanup(dbh);
    215     }
    216 
    217     {
    218         psDB            *dbh;
    219 
    220         dbh = psDBInit("localhost", "test", NULL, "test");
    221         if (!dbh) {
    222             exit(EXIT_FAILURE);
    223         }
    224 
    225         if (!rawScienceExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string")) {
    226             exit(EXIT_FAILURE);
    227         }
    228 
    229         psDBCleanup(dbh);
    230     }
    231 
    232     {
    233         psDB            *dbh;
    234 
    235         dbh = psDBInit("localhost", "test", NULL, "test");
    236         if (!dbh) {
    237             exit(EXIT_FAILURE);
    238         }
    239 
    240         if (!rawImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string")) {
     90        if (!rawDetrendExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z")) {
     91            exit(EXIT_FAILURE);
     92        }
     93
     94        psDBCleanup(dbh);
     95    }
     96
     97    {
     98        psDB            *dbh;
     99
     100        dbh = psDBInit("localhost", "test", NULL, "test");
     101        if (!dbh) {
     102            exit(EXIT_FAILURE);
     103        }
     104
     105        if (!rawScienceExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z")) {
     106            exit(EXIT_FAILURE);
     107        }
     108
     109        psDBCleanup(dbh);
     110    }
     111
     112    {
     113        psDB            *dbh;
     114
     115        dbh = psDBInit("localhost", "test", NULL, "test");
     116        if (!dbh) {
     117            exit(EXIT_FAILURE);
     118        }
     119
     120        if (!rawImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z")) {
    241121            exit(EXIT_FAILURE);
    242122        }

  • trunk/ippdb/tests/insertfits.c

    r9301 r9684  
    2424        }
    2525
    26         if (!weatherInsertFits(dbh, fits)) {
    27             exit(EXIT_FAILURE);
    28         }
    29 
    30         if (!psFitsClose(fits)) {
    31             exit(EXIT_FAILURE);
    32         }
    33 
    34         psDBCleanup(dbh);
    35     }
    36 
    37     {
    38         psDB            *dbh;
    39         psFits          *fits;
    40 
    41         dbh = psDBInit("localhost", "test", NULL, "test");
    42         if (!dbh) {
    43             exit(EXIT_FAILURE);
    44         }
    45 
    46         // open a temp
    47         fits = psFitsOpen(TMP_FILENAME, "r");
    48         if (!fits) {
    49             exit(EXIT_FAILURE);
    50         }
    51 
    52         if (!skyp_transparencyInsertFits(dbh, fits)) {
    53             exit(EXIT_FAILURE);
    54         }
    55 
    56         if (!psFitsClose(fits)) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
    60         psDBCleanup(dbh);
    61     }
    62 
    63     {
    64         psDB            *dbh;
    65         psFits          *fits;
    66 
    67         dbh = psDBInit("localhost", "test", NULL, "test");
    68         if (!dbh) {
    69             exit(EXIT_FAILURE);
    70         }
    71 
    72         // open a temp
    73         fits = psFitsOpen(TMP_FILENAME, "r");
    74         if (!fits) {
    75             exit(EXIT_FAILURE);
    76         }
    77 
    78         if (!skyp_absorptionInsertFits(dbh, fits)) {
    79             exit(EXIT_FAILURE);
    80         }
    81 
    82         if (!psFitsClose(fits)) {
    83             exit(EXIT_FAILURE);
    84         }
    85 
    86         psDBCleanup(dbh);
    87     }
    88 
    89     {
    90         psDB            *dbh;
    91         psFits          *fits;
    92 
    93         dbh = psDBInit("localhost", "test", NULL, "test");
    94         if (!dbh) {
    95             exit(EXIT_FAILURE);
    96         }
    97 
    98         // open a temp
    99         fits = psFitsOpen(TMP_FILENAME, "r");
    100         if (!fits) {
    101             exit(EXIT_FAILURE);
    102         }
    103 
    104         if (!skyp_emissionInsertFits(dbh, fits)) {
    105             exit(EXIT_FAILURE);
    106         }
    107 
    108         if (!psFitsClose(fits)) {
    109             exit(EXIT_FAILURE);
    110         }
    111 
    112         psDBCleanup(dbh);
    113     }
    114 
    115     {
    116         psDB            *dbh;
    117         psFits          *fits;
    118 
    119         dbh = psDBInit("localhost", "test", NULL, "test");
    120         if (!dbh) {
    121             exit(EXIT_FAILURE);
    122         }
    123 
    124         // open a temp
    125         fits = psFitsOpen(TMP_FILENAME, "r");
    126         if (!fits) {
    127             exit(EXIT_FAILURE);
    128         }
    129 
    130         if (!dimmInsertFits(dbh, fits)) {
    131             exit(EXIT_FAILURE);
    132         }
    133 
    134         if (!psFitsClose(fits)) {
    135             exit(EXIT_FAILURE);
    136         }
    137 
    138         psDBCleanup(dbh);
    139     }
    140 
    141     {
    142         psDB            *dbh;
    143         psFits          *fits;
    144 
    145         dbh = psDBInit("localhost", "test", NULL, "test");
    146         if (!dbh) {
    147             exit(EXIT_FAILURE);
    148         }
    149 
    150         // open a temp
    151         fits = psFitsOpen(TMP_FILENAME, "r");
    152         if (!fits) {
    153             exit(EXIT_FAILURE);
    154         }
    155 
    156         if (!skyp_irInsertFits(dbh, fits)) {
    157             exit(EXIT_FAILURE);
    158         }
    159 
    160         if (!psFitsClose(fits)) {
    161             exit(EXIT_FAILURE);
    162         }
    163 
    164         psDBCleanup(dbh);
    165     }
    166 
    167     {
    168         psDB            *dbh;
    169         psFits          *fits;
    170 
    171         dbh = psDBInit("localhost", "test", NULL, "test");
    172         if (!dbh) {
    173             exit(EXIT_FAILURE);
    174         }
    175 
    176         // open a temp
    177         fits = psFitsOpen(TMP_FILENAME, "r");
    178         if (!fits) {
    179             exit(EXIT_FAILURE);
    180         }
    181 
    182         if (!domeInsertFits(dbh, fits)) {
    183             exit(EXIT_FAILURE);
    184         }
    185 
    186         if (!psFitsClose(fits)) {
    187             exit(EXIT_FAILURE);
    188         }
    189 
    190         psDBCleanup(dbh);
    191     }
    192 
    193     {
    194         psDB            *dbh;
    195         psFits          *fits;
    196 
    197         dbh = psDBInit("localhost", "test", NULL, "test");
    198         if (!dbh) {
    199             exit(EXIT_FAILURE);
    200         }
    201 
    202         // open a temp
    203         fits = psFitsOpen(TMP_FILENAME, "r");
    204         if (!fits) {
    205             exit(EXIT_FAILURE);
    206         }
    207 
    208         if (!telescopeInsertFits(dbh, fits)) {
    209             exit(EXIT_FAILURE);
    210         }
    211 
    212         if (!psFitsClose(fits)) {
    213             exit(EXIT_FAILURE);
    214         }
    215 
    216         psDBCleanup(dbh);
    217     }
    218 
    219     {
    220         psDB            *dbh;
    221         psFits          *fits;
    222 
    223         dbh = psDBInit("localhost", "test", NULL, "test");
    224         if (!dbh) {
    225             exit(EXIT_FAILURE);
    226         }
    227 
    228         // open a temp
    229         fits = psFitsOpen(TMP_FILENAME, "r");
    230         if (!fits) {
    231             exit(EXIT_FAILURE);
    232         }
    233 
    23426        if (!summitExpInsertFits(dbh, fits)) {
    23527            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/insertobject.c

    r9423 r9684  
    77    {
    88        psDB            *dbh;
    9         weatherRow      *object;
    10 
    11         dbh = psDBInit("localhost", "test", NULL, "test");
    12         if (!dbh) {
    13             exit(EXIT_FAILURE);
    14         }
    15 
    16         object = weatherRowAlloc(32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32);
    17         if (!object) {
    18             exit(EXIT_FAILURE);
    19         }
    20 
    21         if (!weatherInsertObject(dbh, object)) {
    22             exit(EXIT_FAILURE);
    23         }
    24 
    25         psFree(object);
    26         psDBCleanup(dbh);
    27     }
    28 
    29     {
    30         psDB            *dbh;
    31         skyp_transparencyRow *object;
    32 
    33         dbh = psDBInit("localhost", "test", NULL, "test");
    34         if (!dbh) {
    35             exit(EXIT_FAILURE);
    36         }
    37 
    38         object = skyp_transparencyRowAlloc("a string", 64.64, -32, 64.64, 64.64, 32.32, 64.64);
    39         if (!object) {
    40             exit(EXIT_FAILURE);
    41         }
    42 
    43         if (!skyp_transparencyInsertObject(dbh, object)) {
    44             exit(EXIT_FAILURE);
    45         }
    46 
    47         psFree(object);
    48         psDBCleanup(dbh);
    49     }
    50 
    51     {
    52         psDB            *dbh;
    53         skyp_absorptionRow *object;
    54 
    55         dbh = psDBInit("localhost", "test", NULL, "test");
    56         if (!dbh) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
    60         object = skyp_absorptionRowAlloc("a string", 32.32, 32.32, 32.32, -32, 64.64, 64.64, 32.32, 64.64);
    61         if (!object) {
    62             exit(EXIT_FAILURE);
    63         }
    64 
    65         if (!skyp_absorptionInsertObject(dbh, object)) {
    66             exit(EXIT_FAILURE);
    67         }
    68 
    69         psFree(object);
    70         psDBCleanup(dbh);
    71     }
    72 
    73     {
    74         psDB            *dbh;
    75         skyp_emissionRow *object;
    76 
    77         dbh = psDBInit("localhost", "test", NULL, "test");
    78         if (!dbh) {
    79             exit(EXIT_FAILURE);
    80         }
    81 
    82         object = skyp_emissionRowAlloc("a string", 32.32, 32.32, 32.32, 32.32, 32.32);
    83         if (!object) {
    84             exit(EXIT_FAILURE);
    85         }
    86 
    87         if (!skyp_emissionInsertObject(dbh, object)) {
    88             exit(EXIT_FAILURE);
    89         }
    90 
    91         psFree(object);
    92         psDBCleanup(dbh);
    93     }
    94 
    95     {
    96         psDB            *dbh;
    97         dimmRow         *object;
    98 
    99         dbh = psDBInit("localhost", "test", NULL, "test");
    100         if (!dbh) {
    101             exit(EXIT_FAILURE);
    102         }
    103 
    104         object = dimmRowAlloc(32.32, 32.32, 32.32, 64.64, 64.64, 32.32, "a string");
    105         if (!object) {
    106             exit(EXIT_FAILURE);
    107         }
    108 
    109         if (!dimmInsertObject(dbh, object)) {
    110             exit(EXIT_FAILURE);
    111         }
    112 
    113         psFree(object);
    114         psDBCleanup(dbh);
    115     }
    116 
    117     {
    118         psDB            *dbh;
    119         skyp_irRow      *object;
    120 
    121         dbh = psDBInit("localhost", "test", NULL, "test");
    122         if (!dbh) {
    123             exit(EXIT_FAILURE);
    124         }
    125 
    126         object = skyp_irRowAlloc(64.64, 64.64, 64.64, 64.64, 32.32, 32.32);
    127         if (!object) {
    128             exit(EXIT_FAILURE);
    129         }
    130 
    131         if (!skyp_irInsertObject(dbh, object)) {
    132             exit(EXIT_FAILURE);
    133         }
    134 
    135         psFree(object);
    136         psDBCleanup(dbh);
    137     }
    138 
    139     {
    140         psDB            *dbh;
    141         domeRow         *object;
    142 
    143         dbh = psDBInit("localhost", "test", NULL, "test");
    144         if (!dbh) {
    145             exit(EXIT_FAILURE);
    146         }
    147 
    148         object = domeRowAlloc(32.32, true, true, true);
    149         if (!object) {
    150             exit(EXIT_FAILURE);
    151         }
    152 
    153         if (!domeInsertObject(dbh, object)) {
    154             exit(EXIT_FAILURE);
    155         }
    156 
    157         psFree(object);
    158         psDBCleanup(dbh);
    159     }
    160 
    161     {
    162         psDB            *dbh;
    163         telescopeRow    *object;
    164 
    165         dbh = psDBInit("localhost", "test", NULL, "test");
    166         if (!dbh) {
    167             exit(EXIT_FAILURE);
    168         }
    169 
    170         object = telescopeRowAlloc("a string", 32.32, 32.32, 64.64, 64.64);
    171         if (!object) {
    172             exit(EXIT_FAILURE);
    173         }
    174 
    175         if (!telescopeInsertObject(dbh, object)) {
    176             exit(EXIT_FAILURE);
    177         }
    178 
    179         psFree(object);
    180         psDBCleanup(dbh);
    181     }
    182 
    183     {
    184         psDB            *dbh;
    1859        summitExpRow    *object;
    18610
    … …  
    300124        }
    301125
    302         object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string");
     126        object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    303127        if (!object) {
    304128            exit(EXIT_FAILURE);
    … …  
    322146        }
    323147
    324         object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string");
     148        object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    325149        if (!object) {
    326150            exit(EXIT_FAILURE);
    … …  
    344168        }
    345169
    346         object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string");
     170        object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    347171        if (!object) {
    348172            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/metadatafromobject.c

    r9423 r9684  
    1010    {
    1111        psMetadata      *md;
    12         weatherRow      *object;
    13         bool            status;
    14 
    15         object = weatherRowAlloc(32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32);
    16         if (!object) {
    17             exit(EXIT_FAILURE);
    18         }
    19 
    20         md = weatherMetadataFromObject(object);
    21         if (!md) {
    22             exit(EXIT_FAILURE);
    23         }
    24 
    25         psFree(object);
    26 
    27         if (!psMetadataLookupF32(&status, md, "temp01") == 32.32) {
    28             psFree(md);
    29             exit(EXIT_FAILURE);
    30         }
    31         if (!psMetadataLookupF32(&status, md, "humi01") == 32.32) {
    32             psFree(md);
    33             exit(EXIT_FAILURE);
    34         }
    35         if (!psMetadataLookupF32(&status, md, "temp02") == 32.32) {
    36             psFree(md);
    37             exit(EXIT_FAILURE);
    38         }
    39         if (!psMetadataLookupF32(&status, md, "humi02") == 32.32) {
    40             psFree(md);
    41             exit(EXIT_FAILURE);
    42         }
    43         if (!psMetadataLookupF32(&status, md, "temp03") == 32.32) {
    44             psFree(md);
    45             exit(EXIT_FAILURE);
    46         }
    47         if (!psMetadataLookupF32(&status, md, "humi03") == 32.32) {
    48             psFree(md);
    49             exit(EXIT_FAILURE);
    50         }
    51         if (!psMetadataLookupF32(&status, md, "pressure") == 32.32) {
    52             psFree(md);
    53             exit(EXIT_FAILURE);
    54         }
    55 
    56         psFree(md);
    57     }
    58 
    59     {
    60         psMetadata      *md;
    61         skyp_transparencyRow *object;
    62         bool            status;
    63 
    64         object = skyp_transparencyRowAlloc("a string", 64.64, -32, 64.64, 64.64, 32.32, 64.64);
    65         if (!object) {
    66             exit(EXIT_FAILURE);
    67         }
    68 
    69         md = skyp_transparencyMetadataFromObject(object);
    70         if (!md) {
    71             exit(EXIT_FAILURE);
    72         }
    73 
    74         psFree(object);
    75 
     12        summitExpRow    *object;
     13        bool            status;
     14
     15        object = summitExpRowAlloc("a string", "a string", "a string", "a string", "a string");
     16        if (!object) {
     17            exit(EXIT_FAILURE);
     18        }
     19
     20        md = summitExpMetadataFromObject(object);
     21        if (!md) {
     22            exit(EXIT_FAILURE);
     23        }
     24
     25        psFree(object);
     26
     27        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     28            psFree(md);
     29            exit(EXIT_FAILURE);
     30        }
     31        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     32            psFree(md);
     33            exit(EXIT_FAILURE);
     34        }
     35        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     36            psFree(md);
     37            exit(EXIT_FAILURE);
     38        }
     39        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     40            psFree(md);
     41            exit(EXIT_FAILURE);
     42        }
     43        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     44            psFree(md);
     45            exit(EXIT_FAILURE);
     46        }
     47
     48        psFree(md);
     49    }
     50
     51    {
     52        psMetadata      *md;
     53        pzPendingExpRow *object;
     54        bool            status;
     55
     56        object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32);
     57        if (!object) {
     58            exit(EXIT_FAILURE);
     59        }
     60
     61        md = pzPendingExpMetadataFromObject(object);
     62        if (!md) {
     63            exit(EXIT_FAILURE);
     64        }
     65
     66        psFree(object);
     67
     68        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     69            psFree(md);
     70            exit(EXIT_FAILURE);
     71        }
     72        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     73            psFree(md);
     74            exit(EXIT_FAILURE);
     75        }
     76        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     77            psFree(md);
     78            exit(EXIT_FAILURE);
     79        }
     80        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     81            psFree(md);
     82            exit(EXIT_FAILURE);
     83        }
     84        if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
     85            psFree(md);
     86            exit(EXIT_FAILURE);
     87        }
     88
     89        psFree(md);
     90    }
     91
     92    {
     93        psMetadata      *md;
     94        pzPendingImfileRow *object;
     95        bool            status;
     96
     97        object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string");
     98        if (!object) {
     99            exit(EXIT_FAILURE);
     100        }
     101
     102        md = pzPendingImfileMetadataFromObject(object);
     103        if (!md) {
     104            exit(EXIT_FAILURE);
     105        }
     106
     107        psFree(object);
     108
     109        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     110            psFree(md);
     111            exit(EXIT_FAILURE);
     112        }
     113        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     114            psFree(md);
     115            exit(EXIT_FAILURE);
     116        }
     117        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     118            psFree(md);
     119            exit(EXIT_FAILURE);
     120        }
     121        if (!psMetadataLookupS32(&status, md, "bytes") == -32) {
     122            psFree(md);
     123            exit(EXIT_FAILURE);
     124        }
     125        if (strncmp(psMetadataLookupPtr(&status, md, "md5sum"), "a string", MAX_STRING_LENGTH)) {
     126            psFree(md);
     127            exit(EXIT_FAILURE);
     128        }
     129        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
     130            psFree(md);
     131            exit(EXIT_FAILURE);
     132        }
     133        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     134            psFree(md);
     135            exit(EXIT_FAILURE);
     136        }
     137        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     138            psFree(md);
     139            exit(EXIT_FAILURE);
     140        }
     141
     142        psFree(md);
     143    }
     144
     145    {
     146        psMetadata      *md;
     147        newExpRow       *object;
     148        bool            status;
     149
     150        object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32);
     151        if (!object) {
     152            exit(EXIT_FAILURE);
     153        }
     154
     155        md = newExpMetadataFromObject(object);
     156        if (!md) {
     157            exit(EXIT_FAILURE);
     158        }
     159
     160        psFree(object);
     161
     162        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     163            psFree(md);
     164            exit(EXIT_FAILURE);
     165        }
     166        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     167            psFree(md);
     168            exit(EXIT_FAILURE);
     169        }
     170        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     171            psFree(md);
     172            exit(EXIT_FAILURE);
     173        }
     174        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     175            psFree(md);
     176            exit(EXIT_FAILURE);
     177        }
     178        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     179            psFree(md);
     180            exit(EXIT_FAILURE);
     181        }
     182        if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
     183            psFree(md);
     184            exit(EXIT_FAILURE);
     185        }
     186
     187        psFree(md);
     188    }
     189
     190    {
     191        psMetadata      *md;
     192        newImfileRow    *object;
     193        bool            status;
     194
     195        object = newImfileRowAlloc("a string", "a string", "a string", "a string");
     196        if (!object) {
     197            exit(EXIT_FAILURE);
     198        }
     199
     200        md = newImfileMetadataFromObject(object);
     201        if (!md) {
     202            exit(EXIT_FAILURE);
     203        }
     204
     205        psFree(object);
     206
     207        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     208            psFree(md);
     209            exit(EXIT_FAILURE);
     210        }
     211        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
     212            psFree(md);
     213            exit(EXIT_FAILURE);
     214        }
     215        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     216            psFree(md);
     217            exit(EXIT_FAILURE);
     218        }
     219        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     220            psFree(md);
     221            exit(EXIT_FAILURE);
     222        }
     223
     224        psFree(md);
     225    }
     226
     227    {
     228        psMetadata      *md;
     229        rawDetrendExpRow *object;
     230        bool            status;
     231
     232        object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
     233        if (!object) {
     234            exit(EXIT_FAILURE);
     235        }
     236
     237        md = rawDetrendExpMetadataFromObject(object);
     238        if (!md) {
     239            exit(EXIT_FAILURE);
     240        }
     241
     242        psFree(object);
     243
     244        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     245            psFree(md);
     246            exit(EXIT_FAILURE);
     247        }
     248        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     249            psFree(md);
     250            exit(EXIT_FAILURE);
     251        }
     252        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     253            psFree(md);
     254            exit(EXIT_FAILURE);
     255        }
     256        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     257            psFree(md);
     258            exit(EXIT_FAILURE);
     259        }
     260        if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
     261            psFree(md);
     262            exit(EXIT_FAILURE);
     263        }
    76264        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    77265            psFree(md);
    78266            exit(EXIT_FAILURE);
    79267        }
    80         if (!psMetadataLookupF64(&status, md, "trans") == 64.64) {
    81             psFree(md);
    82             exit(EXIT_FAILURE);
    83         }
    84         if (!psMetadataLookupS32(&status, md, "nstars") == -32) {
     268        if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    85269            psFree(md);
    86270            exit(EXIT_FAILURE);
    … …  
    94278            exit(EXIT_FAILURE);
    95279        }
    96         if (!psMetadataLookupF32(&status, md, "exptime") == 32.32) {
    97             psFree(md);
    98             exit(EXIT_FAILURE);
    99         }
    100         if (!psMetadataLookupF64(&status, md, "sky_bright") == 64.64) {
    101             psFree(md);
    102             exit(EXIT_FAILURE);
    103         }
    104 
    105         psFree(md);
    106     }
    107 
    108     {
    109         psMetadata      *md;
    110         skyp_absorptionRow *object;
    111         bool            status;
    112 
    113         object = skyp_absorptionRowAlloc("a string", 32.32, 32.32, 32.32, -32, 64.64, 64.64, 32.32, 64.64);
    114         if (!object) {
    115             exit(EXIT_FAILURE);
    116         }
    117 
    118         md = skyp_absorptionMetadataFromObject(object);
    119         if (!md) {
    120             exit(EXIT_FAILURE);
    121         }
    122 
    123         psFree(object);
    124 
    125         if (strncmp(psMetadataLookupPtr(&status, md, "disperser_id"), "a string", MAX_STRING_LENGTH)) {
    126             psFree(md);
    127             exit(EXIT_FAILURE);
    128         }
    129         if (!psMetadataLookupF32(&status, md, "atmcomp1") == 32.32) {
    130             psFree(md);
    131             exit(EXIT_FAILURE);
    132         }
    133         if (!psMetadataLookupF32(&status, md, "atmcomp2") == 32.32) {
    134             psFree(md);
    135             exit(EXIT_FAILURE);
    136         }
    137         if (!psMetadataLookupF32(&status, md, "atmcomp3") == 32.32) {
    138             psFree(md);
    139             exit(EXIT_FAILURE);
    140         }
    141         if (!psMetadataLookupS32(&status, md, "nstars") == -32) {
     280        if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) {
     281            psFree(md);
     282            exit(EXIT_FAILURE);
     283        }
     284        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     285            psFree(md);
     286            exit(EXIT_FAILURE);
     287        }
     288        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     289            psFree(md);
     290            exit(EXIT_FAILURE);
     291        }
     292        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     293            psFree(md);
     294            exit(EXIT_FAILURE);
     295        }
     296        if (!psMetadataLookupF64(&status, md, "alt") == 64.64) {
     297            psFree(md);
     298            exit(EXIT_FAILURE);
     299        }
     300        if (!psMetadataLookupF64(&status, md, "az") == 64.64) {
     301            psFree(md);
     302            exit(EXIT_FAILURE);
     303        }
     304        if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) {
     305            psFree(md);
     306            exit(EXIT_FAILURE);
     307        }
     308        if (!psMetadataLookupF64(&status, md, "posang") == 64.64) {
     309            psFree(md);
     310            exit(EXIT_FAILURE);
     311        }
     312        if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) {
     313            psFree(md);
     314            exit(EXIT_FAILURE);
     315        }
     316            psFree(md);
     317            exit(EXIT_FAILURE);
     318        }
     319
     320        psFree(md);
     321    }
     322
     323    {
     324        psMetadata      *md;
     325        rawScienceExpRow *object;
     326        bool            status;
     327
     328        object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
     329        if (!object) {
     330            exit(EXIT_FAILURE);
     331        }
     332
     333        md = rawScienceExpMetadataFromObject(object);
     334        if (!md) {
     335            exit(EXIT_FAILURE);
     336        }
     337
     338        psFree(object);
     339
     340        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     341            psFree(md);
     342            exit(EXIT_FAILURE);
     343        }
     344        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     345            psFree(md);
     346            exit(EXIT_FAILURE);
     347        }
     348        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     349            psFree(md);
     350            exit(EXIT_FAILURE);
     351        }
     352        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     353            psFree(md);
     354            exit(EXIT_FAILURE);
     355        }
     356        if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
     357            psFree(md);
     358            exit(EXIT_FAILURE);
     359        }
     360        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
     361            psFree(md);
     362            exit(EXIT_FAILURE);
     363        }
     364        if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    142365            psFree(md);
    143366            exit(EXIT_FAILURE);
    … …  
    151374            exit(EXIT_FAILURE);
    152375        }
    153         if (!psMetadataLookupF32(&status, md, "exptime") == 32.32) {
    154             psFree(md);
    155             exit(EXIT_FAILURE);
    156         }
    157         if (!psMetadataLookupF64(&status, md, "sky_bright") == 64.64) {
    158             psFree(md);
    159             exit(EXIT_FAILURE);
    160         }
    161 
    162         psFree(md);
    163     }
    164 
    165     {
    166         psMetadata      *md;
    167         skyp_emissionRow *object;
    168         bool            status;
    169 
    170         object = skyp_emissionRowAlloc("a string", 32.32, 32.32, 32.32, 32.32, 32.32);
    171         if (!object) {
    172             exit(EXIT_FAILURE);
    173         }
    174 
    175         md = skyp_emissionMetadataFromObject(object);
    176         if (!md) {
    177             exit(EXIT_FAILURE);
    178         }
    179 
    180         psFree(object);
    181 
    182         if (strncmp(psMetadataLookupPtr(&status, md, "disperser_id"), "a string", MAX_STRING_LENGTH)) {
    183             psFree(md);
    184             exit(EXIT_FAILURE);
    185         }
    186         if (!psMetadataLookupF32(&status, md, "atmcomp1") == 32.32) {
    187             psFree(md);
    188             exit(EXIT_FAILURE);
    189         }
    190         if (!psMetadataLookupF32(&status, md, "atmcomp2") == 32.32) {
    191             psFree(md);
    192             exit(EXIT_FAILURE);
    193         }
    194         if (!psMetadataLookupF32(&status, md, "atmcomp3") == 32.32) {
    195             psFree(md);
    196             exit(EXIT_FAILURE);
    197         }
    198         if (!psMetadataLookupF32(&status, md, "continuum") == 32.32) {
    199             psFree(md);
    200             exit(EXIT_FAILURE);
    201         }
    202         if (!psMetadataLookupF32(&status, md, "exptime") == 32.32) {
    203             psFree(md);
    204             exit(EXIT_FAILURE);
    205         }
    206 
    207         psFree(md);
    208     }
    209 
    210     {
    211         psMetadata      *md;
    212         dimmRow         *object;
    213         bool            status;
    214 
    215         object = dimmRowAlloc(32.32, 32.32, 32.32, 64.64, 64.64, 32.32, "a string");
    216         if (!object) {
    217             exit(EXIT_FAILURE);
    218         }
    219 
    220         md = dimmMetadataFromObject(object);
    221         if (!md) {
    222             exit(EXIT_FAILURE);
    223         }
    224 
    225         psFree(object);
    226 
    227         if (!psMetadataLookupF32(&status, md, "sigmax") == 32.32) {
    228             psFree(md);
    229             exit(EXIT_FAILURE);
    230         }
    231         if (!psMetadataLookupF32(&status, md, "sigmay") == 32.32) {
    232             psFree(md);
    233             exit(EXIT_FAILURE);
    234         }
    235         if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
     376        if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) {
     377            psFree(md);
     378            exit(EXIT_FAILURE);
     379        }
     380        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     381            psFree(md);
     382            exit(EXIT_FAILURE);
     383        }
     384        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     385            psFree(md);
     386            exit(EXIT_FAILURE);
     387        }
     388        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     389            psFree(md);
     390            exit(EXIT_FAILURE);
     391        }
     392        if (!psMetadataLookupF64(&status, md, "alt") == 64.64) {
     393            psFree(md);
     394            exit(EXIT_FAILURE);
     395        }
     396        if (!psMetadataLookupF64(&status, md, "az") == 64.64) {
     397            psFree(md);
     398            exit(EXIT_FAILURE);
     399        }
     400        if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) {
     401            psFree(md);
     402            exit(EXIT_FAILURE);
     403        }
     404        if (!psMetadataLookupF64(&status, md, "posang") == 64.64) {
     405            psFree(md);
     406            exit(EXIT_FAILURE);
     407        }
     408        if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) {
     409            psFree(md);
     410            exit(EXIT_FAILURE);
     411        }
     412            psFree(md);
     413            exit(EXIT_FAILURE);
     414        }
     415
     416        psFree(md);
     417    }
     418
     419    {
     420        psMetadata      *md;
     421        rawImfileRow    *object;
     422        bool            status;
     423
     424        object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
     425        if (!object) {
     426            exit(EXIT_FAILURE);
     427        }
     428
     429        md = rawImfileMetadataFromObject(object);
     430        if (!md) {
     431            exit(EXIT_FAILURE);
     432        }
     433
     434        psFree(object);
     435
     436        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     437            psFree(md);
     438            exit(EXIT_FAILURE);
     439        }
     440        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
     441            psFree(md);
     442            exit(EXIT_FAILURE);
     443        }
     444        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     445            psFree(md);
     446            exit(EXIT_FAILURE);
     447        }
     448        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     449            psFree(md);
     450            exit(EXIT_FAILURE);
     451        }
     452        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     453            psFree(md);
     454            exit(EXIT_FAILURE);
     455        }
     456        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
     457            psFree(md);
     458            exit(EXIT_FAILURE);
     459        }
     460        if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    236461            psFree(md);
    237462            exit(EXIT_FAILURE);
    … …  
    245470            exit(EXIT_FAILURE);
    246471        }
    247         if (!psMetadataLookupF32(&status, md, "expttime") == 32.32) {
    248             psFree(md);
    249             exit(EXIT_FAILURE);
    250         }
    251         if (strncmp(psMetadataLookupPtr(&status, md, "telescope_id"), "a string", MAX_STRING_LENGTH)) {
    252             psFree(md);
    253             exit(EXIT_FAILURE);
    254         }
    255 
    256         psFree(md);
    257     }
    258 
    259     {
    260         psMetadata      *md;
    261         skyp_irRow      *object;
    262         bool            status;
    263 
    264         object = skyp_irRowAlloc(64.64, 64.64, 64.64, 64.64, 32.32, 32.32);
    265         if (!object) {
    266             exit(EXIT_FAILURE);
    267         }
    268 
    269         md = skyp_irMetadataFromObject(object);
    270         if (!md) {
    271             exit(EXIT_FAILURE);
    272         }
    273 
    274         psFree(object);
    275 
    276         if (!psMetadataLookupF64(&status, md, "sky_bright") == 64.64) {
    277             psFree(md);
    278             exit(EXIT_FAILURE);
    279         }
    280         if (!psMetadataLookupF64(&status, md, "sky_var") == 64.64) {
    281             psFree(md);
    282             exit(EXIT_FAILURE);
    283         }
    284         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    285             psFree(md);
    286             exit(EXIT_FAILURE);
    287         }
    288         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    289             psFree(md);
    290             exit(EXIT_FAILURE);
    291         }
    292         if (!psMetadataLookupF32(&status, md, "fov_x") == 32.32) {
    293             psFree(md);
    294             exit(EXIT_FAILURE);
    295         }
    296         if (!psMetadataLookupF32(&status, md, "fov_y") == 32.32) {
    297             psFree(md);
    298             exit(EXIT_FAILURE);
    299         }
    300 
    301         psFree(md);
    302     }
    303 
    304     {
    305         psMetadata      *md;
    306         domeRow         *object;
    307         bool            status;
    308 
    309         object = domeRowAlloc(32.32, true, true, true);
    310         if (!object) {
    311             exit(EXIT_FAILURE);
    312         }
    313 
    314         md = domeMetadataFromObject(object);
    315         if (!md) {
    316             exit(EXIT_FAILURE);
    317         }
    318 
    319         psFree(object);
    320 
    321         if (!psMetadataLookupF32(&status, md, "az") == 32.32) {
    322             psFree(md);
    323             exit(EXIT_FAILURE);
    324         }
    325         if (!psMetadataLookupBool(&status, md, "open") == true) {
    326             psFree(md);
    327             exit(EXIT_FAILURE);
    328         }
    329         if (!psMetadataLookupBool(&status, md, "light") == true) {
    330             psFree(md);
    331             exit(EXIT_FAILURE);
    332         }
    333         if (!psMetadataLookupBool(&status, md, "track") == true) {
    334             psFree(md);
    335             exit(EXIT_FAILURE);
    336         }
    337 
    338         psFree(md);
    339     }
    340 
    341     {
    342         psMetadata      *md;
    343         telescopeRow    *object;
    344         bool            status;
    345 
    346         object = telescopeRowAlloc("a string", 32.32, 32.32, 64.64, 64.64);
    347         if (!object) {
    348             exit(EXIT_FAILURE);
    349         }
    350 
    351         md = telescopeMetadataFromObject(object);
    352         if (!md) {
    353             exit(EXIT_FAILURE);
    354         }
    355 
    356         psFree(object);
    357 
    358         if (strncmp(psMetadataLookupPtr(&status, md, "guide"), "a string", MAX_STRING_LENGTH)) {
    359             psFree(md);
    360             exit(EXIT_FAILURE);
    361         }
    362         if (!psMetadataLookupF32(&status, md, "alt") == 32.32) {
    363             psFree(md);
    364             exit(EXIT_FAILURE);
    365         }
    366         if (!psMetadataLookupF32(&status, md, "az") == 32.32) {
    367             psFree(md);
    368             exit(EXIT_FAILURE);
    369         }
    370         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    371             psFree(md);
    372             exit(EXIT_FAILURE);
    373         }
    374         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    375             psFree(md);
    376             exit(EXIT_FAILURE);
    377         }
    378 
    379         psFree(md);
    380     }
    381 
    382     {
    383         psMetadata      *md;
    384         summitExpRow    *object;
    385         bool            status;
    386 
    387         object = summitExpRowAlloc("a string", "a string", "a string", "a string", "a string");
    388         if (!object) {
    389             exit(EXIT_FAILURE);
    390         }
    391 
    392         md = summitExpMetadataFromObject(object);
    393         if (!md) {
    394             exit(EXIT_FAILURE);
    395         }
    396 
    397         psFree(object);
    398 
    399         if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
    400             psFree(md);
    401             exit(EXIT_FAILURE);
    402         }
    403         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    404             psFree(md);
    405             exit(EXIT_FAILURE);
    406         }
    407         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    408             psFree(md);
    409             exit(EXIT_FAILURE);
    410         }
    411         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    412             psFree(md);
    413             exit(EXIT_FAILURE);
    414         }
    415         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    416             psFree(md);
    417             exit(EXIT_FAILURE);
    418         }
    419 
    420         psFree(md);
    421     }
    422 
    423     {
    424         psMetadata      *md;
    425         pzPendingExpRow *object;
    426         bool            status;
    427 
    428         object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32);
    429         if (!object) {
    430             exit(EXIT_FAILURE);
    431         }
    432 
    433         md = pzPendingExpMetadataFromObject(object);
    434         if (!md) {
    435             exit(EXIT_FAILURE);
    436         }
    437 
    438         psFree(object);
    439 
    440         if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
    441             psFree(md);
    442             exit(EXIT_FAILURE);
    443         }
    444         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    445             psFree(md);
    446             exit(EXIT_FAILURE);
    447         }
    448         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    449             psFree(md);
    450             exit(EXIT_FAILURE);
    451         }
    452         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    453             psFree(md);
    454             exit(EXIT_FAILURE);
    455         }
    456         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    457             psFree(md);
    458             exit(EXIT_FAILURE);
    459         }
    460 
    461         psFree(md);
    462     }
    463 
    464     {
    465         psMetadata      *md;
    466         pzPendingImfileRow *object;
    467         bool            status;
    468 
    469         object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string");
    470         if (!object) {
    471             exit(EXIT_FAILURE);
    472         }
    473 
    474         md = pzPendingImfileMetadataFromObject(object);
    475         if (!md) {
    476             exit(EXIT_FAILURE);
    477         }
    478 
    479         psFree(object);
    480 
    481         if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
    482             psFree(md);
    483             exit(EXIT_FAILURE);
    484         }
    485         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    486             psFree(md);
    487             exit(EXIT_FAILURE);
    488         }
    489         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    490             psFree(md);
    491             exit(EXIT_FAILURE);
    492         }
    493         if (!psMetadataLookupS32(&status, md, "bytes") == -32) {
    494             psFree(md);
    495             exit(EXIT_FAILURE);
    496         }
    497         if (strncmp(psMetadataLookupPtr(&status, md, "md5sum"), "a string", MAX_STRING_LENGTH)) {
    498             psFree(md);
    499             exit(EXIT_FAILURE);
    500         }
    501         if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
    502             psFree(md);
    503             exit(EXIT_FAILURE);
    504         }
    505         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    506             psFree(md);
    507             exit(EXIT_FAILURE);
    508         }
    509         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    510             psFree(md);
    511             exit(EXIT_FAILURE);
    512         }
    513 
    514         psFree(md);
    515     }
    516 
    517     {
    518         psMetadata      *md;
    519         newExpRow       *object;
    520         bool            status;
    521 
    522         object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32);
    523         if (!object) {
    524             exit(EXIT_FAILURE);
    525         }
    526 
    527         md = newExpMetadataFromObject(object);
    528         if (!md) {
    529             exit(EXIT_FAILURE);
    530         }
    531 
    532         psFree(object);
    533 
    534         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    535             psFree(md);
    536             exit(EXIT_FAILURE);
    537         }
    538         if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
    539             psFree(md);
    540             exit(EXIT_FAILURE);
    541         }
    542         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    543             psFree(md);
    544             exit(EXIT_FAILURE);
    545         }
    546         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    547             psFree(md);
    548             exit(EXIT_FAILURE);
    549         }
    550         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    551             psFree(md);
    552             exit(EXIT_FAILURE);
    553         }
    554         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    555             psFree(md);
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psFree(md);
    560     }
    561 
    562     {
    563         psMetadata      *md;
    564         newImfileRow    *object;
    565         bool            status;
    566 
    567         object = newImfileRowAlloc("a string", "a string", "a string", "a string");
    568         if (!object) {
    569             exit(EXIT_FAILURE);
    570         }
    571 
    572         md = newImfileMetadataFromObject(object);
    573         if (!md) {
    574             exit(EXIT_FAILURE);
    575         }
    576 
    577         psFree(object);
    578 
    579         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    580             psFree(md);
    581             exit(EXIT_FAILURE);
    582         }
    583         if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
    584             psFree(md);
    585             exit(EXIT_FAILURE);
    586         }
    587         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    588             psFree(md);
    589             exit(EXIT_FAILURE);
    590         }
    591         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    592             psFree(md);
    593             exit(EXIT_FAILURE);
    594         }
    595 
    596         psFree(md);
    597     }
    598 
    599     {
    600         psMetadata      *md;
    601         rawDetrendExpRow *object;
    602         bool            status;
    603 
    604         object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string");
    605         if (!object) {
    606             exit(EXIT_FAILURE);
    607         }
    608 
    609         md = rawDetrendExpMetadataFromObject(object);
    610         if (!md) {
    611             exit(EXIT_FAILURE);
    612         }
    613 
    614         psFree(object);
    615 
    616         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    617             psFree(md);
    618             exit(EXIT_FAILURE);
    619         }
    620         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    621             psFree(md);
    622             exit(EXIT_FAILURE);
    623         }
    624         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    625             psFree(md);
    626             exit(EXIT_FAILURE);
    627         }
    628         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    629             psFree(md);
    630             exit(EXIT_FAILURE);
    631         }
    632         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    633             psFree(md);
    634             exit(EXIT_FAILURE);
    635         }
    636         if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    637             psFree(md);
    638             exit(EXIT_FAILURE);
    639         }
    640         if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    641             psFree(md);
    642             exit(EXIT_FAILURE);
    643         }
    644         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    645             psFree(md);
    646             exit(EXIT_FAILURE);
    647         }
    648         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    649             psFree(md);
    650             exit(EXIT_FAILURE);
    651         }
    652472        if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) {
    653473            psFree(md);
    … …  
    686506            exit(EXIT_FAILURE);
    687507        }
    688 
    689         psFree(md);
    690     }
    691 
    692     {
    693         psMetadata      *md;
    694         rawScienceExpRow *object;
    695         bool            status;
    696 
    697         object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string");
    698         if (!object) {
    699             exit(EXIT_FAILURE);
    700         }
    701 
    702         md = rawScienceExpMetadataFromObject(object);
    703         if (!md) {
    704             exit(EXIT_FAILURE);
    705         }
    706 
    707         psFree(object);
    708 
    709         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    710             psFree(md);
    711             exit(EXIT_FAILURE);
    712         }
    713         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    714             psFree(md);
    715             exit(EXIT_FAILURE);
    716         }
    717         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    718             psFree(md);
    719             exit(EXIT_FAILURE);
    720         }
    721         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    722             psFree(md);
    723             exit(EXIT_FAILURE);
    724         }
    725         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    726             psFree(md);
    727             exit(EXIT_FAILURE);
    728         }
    729         if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    730             psFree(md);
    731             exit(EXIT_FAILURE);
    732         }
    733         if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    734             psFree(md);
    735             exit(EXIT_FAILURE);
    736         }
    737         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    738             psFree(md);
    739             exit(EXIT_FAILURE);
    740         }
    741         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    742             psFree(md);
    743             exit(EXIT_FAILURE);
    744         }
    745         if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) {
    746             psFree(md);
    747             exit(EXIT_FAILURE);
    748         }
    749         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    750             psFree(md);
    751             exit(EXIT_FAILURE);
    752         }
    753         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    754             psFree(md);
    755             exit(EXIT_FAILURE);
    756         }
    757         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    758             psFree(md);
    759             exit(EXIT_FAILURE);
    760         }
    761         if (!psMetadataLookupF64(&status, md, "alt") == 64.64) {
    762             psFree(md);
    763             exit(EXIT_FAILURE);
    764         }
    765         if (!psMetadataLookupF64(&status, md, "az") == 64.64) {
    766             psFree(md);
    767             exit(EXIT_FAILURE);
    768         }
    769         if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) {
    770             psFree(md);
    771             exit(EXIT_FAILURE);
    772         }
    773         if (!psMetadataLookupF64(&status, md, "posang") == 64.64) {
    774             psFree(md);
    775             exit(EXIT_FAILURE);
    776         }
    777         if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) {
    778             psFree(md);
    779             exit(EXIT_FAILURE);
    780         }
    781 
    782         psFree(md);
    783     }
    784 
    785     {
    786         psMetadata      *md;
    787         rawImfileRow    *object;
    788         bool            status;
    789 
    790         object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string");
    791         if (!object) {
    792             exit(EXIT_FAILURE);
    793         }
    794 
    795         md = rawImfileMetadataFromObject(object);
    796         if (!md) {
    797             exit(EXIT_FAILURE);
    798         }
    799 
    800         psFree(object);
    801 
    802         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    803             psFree(md);
    804             exit(EXIT_FAILURE);
    805         }
    806         if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
    807             psFree(md);
    808             exit(EXIT_FAILURE);
    809         }
    810         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    811             psFree(md);
    812             exit(EXIT_FAILURE);
    813         }
    814         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    815             psFree(md);
    816             exit(EXIT_FAILURE);
    817         }
    818         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    819             psFree(md);
    820             exit(EXIT_FAILURE);
    821         }
    822         if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    823             psFree(md);
    824             exit(EXIT_FAILURE);
    825         }
    826         if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    827             psFree(md);
    828             exit(EXIT_FAILURE);
    829         }
    830         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    831             psFree(md);
    832             exit(EXIT_FAILURE);
    833         }
    834         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    835             psFree(md);
    836             exit(EXIT_FAILURE);
    837         }
    838         if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) {
    839             psFree(md);
    840             exit(EXIT_FAILURE);
    841         }
    842         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    843             psFree(md);
    844             exit(EXIT_FAILURE);
    845         }
    846         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    847             psFree(md);
    848             exit(EXIT_FAILURE);
    849         }
    850         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    851             psFree(md);
    852             exit(EXIT_FAILURE);
    853         }
    854         if (!psMetadataLookupF64(&status, md, "alt") == 64.64) {
    855             psFree(md);
    856             exit(EXIT_FAILURE);
    857         }
    858         if (!psMetadataLookupF64(&status, md, "az") == 64.64) {
    859             psFree(md);
    860             exit(EXIT_FAILURE);
    861         }
    862         if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) {
    863             psFree(md);
    864             exit(EXIT_FAILURE);
    865         }
    866         if (!psMetadataLookupF64(&status, md, "posang") == 64.64) {
    867             psFree(md);
    868             exit(EXIT_FAILURE);
    869         }
    870         if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) {
    871508            psFree(md);
    872509            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r9423 r9684  
    1010    {
    1111        psMetadata      *md;
    12         weatherRow      *object;
    13 
    14         md = psMetadataAlloc();
    15         if (!psMetadataAddF32(md, PS_LIST_TAIL, "temp01", 0, NULL, 32.32)) {
    16             psFree(md);
    17             exit(EXIT_FAILURE);
    18         }
    19         if (!psMetadataAddF32(md, PS_LIST_TAIL, "humi01", 0, NULL, 32.32)) {
    20             psFree(md);
    21             exit(EXIT_FAILURE);
    22         }
    23         if (!psMetadataAddF32(md, PS_LIST_TAIL, "temp02", 0, NULL, 32.32)) {
    24             psFree(md);
    25             exit(EXIT_FAILURE);
    26         }
    27         if (!psMetadataAddF32(md, PS_LIST_TAIL, "humi02", 0, NULL, 32.32)) {
    28             psFree(md);
    29             exit(EXIT_FAILURE);
    30         }
    31         if (!psMetadataAddF32(md, PS_LIST_TAIL, "temp03", 0, NULL, 32.32)) {
    32             psFree(md);
    33             exit(EXIT_FAILURE);
    34         }
    35         if (!psMetadataAddF32(md, PS_LIST_TAIL, "humi03", 0, NULL, 32.32)) {
    36             psFree(md);
    37             exit(EXIT_FAILURE);
    38         }
    39         if (!psMetadataAddF32(md, PS_LIST_TAIL, "pressure", 0, NULL, 32.32)) {
    40             psFree(md);
    41             exit(EXIT_FAILURE);
    42         }
    43 
    44         object = weatherObjectFromMetadata(md);
    45         if (!object) {
    46             psFree(md);
    47             exit(EXIT_FAILURE);
    48         }
    49 
    50         psFree(md);
    51 
    52         if (!object->temp01 == 32.32) {
    53             psFree(object);
    54             exit(EXIT_FAILURE);
    55         }
    56         if (!object->humi01 == 32.32) {
    57             psFree(object);
    58             exit(EXIT_FAILURE);
    59         }
    60         if (!object->temp02 == 32.32) {
    61             psFree(object);
    62             exit(EXIT_FAILURE);
    63         }
    64         if (!object->humi02 == 32.32) {
    65             psFree(object);
    66             exit(EXIT_FAILURE);
    67         }
    68         if (!object->temp03 == 32.32) {
    69             psFree(object);
    70             exit(EXIT_FAILURE);
    71         }
    72         if (!object->humi03 == 32.32) {
    73             psFree(object);
    74             exit(EXIT_FAILURE);
    75         }
    76         if (!object->pressure == 32.32) {
    77             psFree(object);
    78             exit(EXIT_FAILURE);
    79         }
    80 
    81         psFree(object);
    82     }
    83 
    84     {
    85         psMetadata      *md;
    86         skyp_transparencyRow *object;
    87 
    88         md = psMetadataAlloc();
     12        summitExpRow    *object;
     13
     14        md = psMetadataAlloc();
     15        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     16            psFree(md);
     17            exit(EXIT_FAILURE);
     18        }
     19        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     20            psFree(md);
     21            exit(EXIT_FAILURE);
     22        }
     23        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     24            psFree(md);
     25            exit(EXIT_FAILURE);
     26        }
     27        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
     28            psFree(md);
     29            exit(EXIT_FAILURE);
     30        }
     31        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     32            psFree(md);
     33            exit(EXIT_FAILURE);
     34        }
     35
     36        object = summitExpObjectFromMetadata(md);
     37        if (!object) {
     38            psFree(md);
     39            exit(EXIT_FAILURE);
     40        }
     41
     42        psFree(md);
     43
     44        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     45            psFree(object);
     46            exit(EXIT_FAILURE);
     47        }
     48        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     49            psFree(object);
     50            exit(EXIT_FAILURE);
     51        }
     52        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     53            psFree(object);
     54            exit(EXIT_FAILURE);
     55        }
     56        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     57            psFree(object);
     58            exit(EXIT_FAILURE);
     59        }
     60        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     61            psFree(object);
     62            exit(EXIT_FAILURE);
     63        }
     64
     65        psFree(object);
     66    }
     67
     68    {
     69        psMetadata      *md;
     70        pzPendingExpRow *object;
     71
     72        md = psMetadataAlloc();
     73        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     74            psFree(md);
     75            exit(EXIT_FAILURE);
     76        }
     77        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     78            psFree(md);
     79            exit(EXIT_FAILURE);
     80        }
     81        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     82            psFree(md);
     83            exit(EXIT_FAILURE);
     84        }
     85        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
     86            psFree(md);
     87            exit(EXIT_FAILURE);
     88        }
     89        if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
     90            psFree(md);
     91            exit(EXIT_FAILURE);
     92        }
     93
     94        object = pzPendingExpObjectFromMetadata(md);
     95        if (!object) {
     96            psFree(md);
     97            exit(EXIT_FAILURE);
     98        }
     99
     100        psFree(md);
     101
     102        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     103            psFree(object);
     104            exit(EXIT_FAILURE);
     105        }
     106        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     107            psFree(object);
     108            exit(EXIT_FAILURE);
     109        }
     110        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     111            psFree(object);
     112            exit(EXIT_FAILURE);
     113        }
     114        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     115            psFree(object);
     116            exit(EXIT_FAILURE);
     117        }
     118        if (!object->imfiles == -32) {
     119            psFree(object);
     120            exit(EXIT_FAILURE);
     121        }
     122
     123        psFree(object);
     124    }
     125
     126    {
     127        psMetadata      *md;
     128        pzPendingImfileRow *object;
     129
     130        md = psMetadataAlloc();
     131        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     132            psFree(md);
     133            exit(EXIT_FAILURE);
     134        }
     135        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     136            psFree(md);
     137            exit(EXIT_FAILURE);
     138        }
     139        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     140            psFree(md);
     141            exit(EXIT_FAILURE);
     142        }
     143        if (!psMetadataAddS32(md, PS_LIST_TAIL, "bytes", 0, NULL, -32)) {
     144            psFree(md);
     145            exit(EXIT_FAILURE);
     146        }
     147        if (!psMetadataAddStr(md, PS_LIST_TAIL, "md5sum", 0, NULL, "a string")) {
     148            psFree(md);
     149            exit(EXIT_FAILURE);
     150        }
     151        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     152            psFree(md);
     153            exit(EXIT_FAILURE);
     154        }
     155        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     156            psFree(md);
     157            exit(EXIT_FAILURE);
     158        }
     159        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     160            psFree(md);
     161            exit(EXIT_FAILURE);
     162        }
     163
     164        object = pzPendingImfileObjectFromMetadata(md);
     165        if (!object) {
     166            psFree(md);
     167            exit(EXIT_FAILURE);
     168        }
     169
     170        psFree(md);
     171
     172        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     173            psFree(object);
     174            exit(EXIT_FAILURE);
     175        }
     176        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     177            psFree(object);
     178            exit(EXIT_FAILURE);
     179        }
     180        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     181            psFree(object);
     182            exit(EXIT_FAILURE);
     183        }
     184        if (!object->bytes == -32) {
     185            psFree(object);
     186            exit(EXIT_FAILURE);
     187        }
     188        if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
     189            psFree(object);
     190            exit(EXIT_FAILURE);
     191        }
     192        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     193            psFree(object);
     194            exit(EXIT_FAILURE);
     195        }
     196        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     197            psFree(object);
     198            exit(EXIT_FAILURE);
     199        }
     200        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     201            psFree(object);
     202            exit(EXIT_FAILURE);
     203        }
     204
     205        psFree(object);
     206    }
     207
     208    {
     209        psMetadata      *md;
     210        newExpRow       *object;
     211
     212        md = psMetadataAlloc();
     213        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     214            psFree(md);
     215            exit(EXIT_FAILURE);
     216        }
     217        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     218            psFree(md);
     219            exit(EXIT_FAILURE);
     220        }
     221        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     222            psFree(md);
     223            exit(EXIT_FAILURE);
     224        }
     225        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     226            psFree(md);
     227            exit(EXIT_FAILURE);
     228        }
     229        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
     230            psFree(md);
     231            exit(EXIT_FAILURE);
     232        }
     233        if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
     234            psFree(md);
     235            exit(EXIT_FAILURE);
     236        }
     237
     238        object = newExpObjectFromMetadata(md);
     239        if (!object) {
     240            psFree(md);
     241            exit(EXIT_FAILURE);
     242        }
     243
     244        psFree(md);
     245
     246        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     247            psFree(object);
     248            exit(EXIT_FAILURE);
     249        }
     250        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     251            psFree(object);
     252            exit(EXIT_FAILURE);
     253        }
     254        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     255            psFree(object);
     256            exit(EXIT_FAILURE);
     257        }
     258        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     259            psFree(object);
     260            exit(EXIT_FAILURE);
     261        }
     262        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     263            psFree(object);
     264            exit(EXIT_FAILURE);
     265        }
     266        if (!object->imfiles == -32) {
     267            psFree(object);
     268            exit(EXIT_FAILURE);
     269        }
     270
     271        psFree(object);
     272    }
     273
     274    {
     275        psMetadata      *md;
     276        newImfileRow    *object;
     277
     278        md = psMetadataAlloc();
     279        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     280            psFree(md);
     281            exit(EXIT_FAILURE);
     282        }
     283        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     284            psFree(md);
     285            exit(EXIT_FAILURE);
     286        }
     287        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     288            psFree(md);
     289            exit(EXIT_FAILURE);
     290        }
     291        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     292            psFree(md);
     293            exit(EXIT_FAILURE);
     294        }
     295
     296        object = newImfileObjectFromMetadata(md);
     297        if (!object) {
     298            psFree(md);
     299            exit(EXIT_FAILURE);
     300        }
     301
     302        psFree(md);
     303
     304        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     305            psFree(object);
     306            exit(EXIT_FAILURE);
     307        }
     308        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     309            psFree(object);
     310            exit(EXIT_FAILURE);
     311        }
     312        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     313            psFree(object);
     314            exit(EXIT_FAILURE);
     315        }
     316        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     317            psFree(object);
     318            exit(EXIT_FAILURE);
     319        }
     320
     321        psFree(object);
     322    }
     323
     324    {
     325        psMetadata      *md;
     326        rawDetrendExpRow *object;
     327
     328        md = psMetadataAlloc();
     329        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     330            psFree(md);
     331            exit(EXIT_FAILURE);
     332        }
     333        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     334            psFree(md);
     335            exit(EXIT_FAILURE);
     336        }
     337        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     338            psFree(md);
     339            exit(EXIT_FAILURE);
     340        }
     341        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
     342            psFree(md);
     343            exit(EXIT_FAILURE);
     344        }
     345        if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
     346            psFree(md);
     347            exit(EXIT_FAILURE);
     348        }
    89349        if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
    90350            psFree(md);
    91351            exit(EXIT_FAILURE);
    92352        }
    93         if (!psMetadataAddF64(md, PS_LIST_TAIL, "trans", 0, NULL, 64.64)) {
    94             psFree(md);
    95             exit(EXIT_FAILURE);
    96         }
    97         if (!psMetadataAddS32(md, PS_LIST_TAIL, "nstars", 0, NULL, -32)) {
     353        if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    98354            psFree(md);
    99355            exit(EXIT_FAILURE);
    … …  
    107363            exit(EXIT_FAILURE);
    108364        }
    109         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exptime", 0, NULL, 32.32)) {
    110             psFree(md);
    111             exit(EXIT_FAILURE);
    112         }
    113         if (!psMetadataAddF64(md, PS_LIST_TAIL, "sky_bright", 0, NULL, 64.64)) {
    114             psFree(md);
    115             exit(EXIT_FAILURE);
    116         }
    117 
    118         object = skyp_transparencyObjectFromMetadata(md);
    119         if (!object) {
    120             psFree(md);
    121             exit(EXIT_FAILURE);
    122         }
    123 
    124         psFree(md);
    125 
     365        if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
     366            psFree(md);
     367            exit(EXIT_FAILURE);
     368        }
     369        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
     370            psFree(md);
     371            exit(EXIT_FAILURE);
     372        }
     373        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
     374            psFree(md);
     375            exit(EXIT_FAILURE);
     376        }
     377        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     378            psFree(md);
     379            exit(EXIT_FAILURE);
     380        }
     381        if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
     382            psFree(md);
     383            exit(EXIT_FAILURE);
     384        }
     385        if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
     386            psFree(md);
     387            exit(EXIT_FAILURE);
     388        }
     389        if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
     390            psFree(md);
     391            exit(EXIT_FAILURE);
     392        }
     393        if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
     394            psFree(md);
     395            exit(EXIT_FAILURE);
     396        }
     397        if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
     398            psFree(md);
     399            exit(EXIT_FAILURE);
     400        }
     401            psFree(md);
     402            exit(EXIT_FAILURE);
     403        }
     404
     405        object = rawDetrendExpObjectFromMetadata(md);
     406        if (!object) {
     407            psFree(md);
     408            exit(EXIT_FAILURE);
     409        }
     410
     411        psFree(md);
     412
     413        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     414            psFree(object);
     415            exit(EXIT_FAILURE);
     416        }
     417        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     418            psFree(object);
     419            exit(EXIT_FAILURE);
     420        }
     421        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     422            psFree(object);
     423            exit(EXIT_FAILURE);
     424        }
     425        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     426            psFree(object);
     427            exit(EXIT_FAILURE);
     428        }
     429        if (!object->imfiles == -32) {
     430            psFree(object);
     431            exit(EXIT_FAILURE);
     432        }
    126433        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    127434            psFree(object);
    128435            exit(EXIT_FAILURE);
    129436        }
    130         if (!object->trans == 64.64) {
    131             psFree(object);
    132             exit(EXIT_FAILURE);
    133         }
    134         if (!object->nstars == -32) {
     437        if (!object->airmass == 32.32) {
    135438            psFree(object);
    136439            exit(EXIT_FAILURE);
    … …  
    144447            exit(EXIT_FAILURE);
    145448        }
    146         if (!object->exptime == 32.32) {
    147             psFree(object);
    148             exit(EXIT_FAILURE);
    149         }
    150         if (!object->sky_bright == 64.64) {
    151             psFree(object);
    152             exit(EXIT_FAILURE);
    153         }
    154 
    155         psFree(object);
    156     }
    157 
    158     {
    159         psMetadata      *md;
    160         skyp_absorptionRow *object;
    161 
    162         md = psMetadataAlloc();
    163         if (!psMetadataAddStr(md, PS_LIST_TAIL, "disperser_id", 0, NULL, "a string")) {
    164             psFree(md);
    165             exit(EXIT_FAILURE);
    166         }
    167         if (!psMetadataAddF32(md, PS_LIST_TAIL, "atmcomp1", 0, NULL, 32.32)) {
    168             psFree(md);
    169             exit(EXIT_FAILURE);
    170         }
    171         if (!psMetadataAddF32(md, PS_LIST_TAIL, "atmcomp2", 0, NULL, 32.32)) {
    172             psFree(md);
    173             exit(EXIT_FAILURE);
    174         }
    175         if (!psMetadataAddF32(md, PS_LIST_TAIL, "atmcomp3", 0, NULL, 32.32)) {
    176             psFree(md);
    177             exit(EXIT_FAILURE);
    178         }
    179         if (!psMetadataAddS32(md, PS_LIST_TAIL, "nstars", 0, NULL, -32)) {
     449        if (!object->exp_time == 32.32) {
     450            psFree(object);
     451            exit(EXIT_FAILURE);
     452        }
     453        if (!object->bg == 64.64) {
     454            psFree(object);
     455            exit(EXIT_FAILURE);
     456        }
     457        if (!object->bg_stdev == 64.64) {
     458            psFree(object);
     459            exit(EXIT_FAILURE);
     460        }
     461        if (!object->bg_mean_stdev == 64.64) {
     462            psFree(object);
     463            exit(EXIT_FAILURE);
     464        }
     465        if (!object->alt == 64.64) {
     466            psFree(object);
     467            exit(EXIT_FAILURE);
     468        }
     469        if (!object->az == 64.64) {
     470            psFree(object);
     471            exit(EXIT_FAILURE);
     472        }
     473        if (!object->ccd_temp == 32.32) {
     474            psFree(object);
     475            exit(EXIT_FAILURE);
     476        }
     477        if (!object->posang == 64.64) {
     478            psFree(object);
     479            exit(EXIT_FAILURE);
     480        }
     481        if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
     482            psFree(object);
     483            exit(EXIT_FAILURE);
     484        }
     485            psFree(object);
     486            exit(EXIT_FAILURE);
     487        }
     488
     489        psFree(object);
     490    }
     491
     492    {
     493        psMetadata      *md;
     494        rawScienceExpRow *object;
     495
     496        md = psMetadataAlloc();
     497        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     498            psFree(md);
     499            exit(EXIT_FAILURE);
     500        }
     501        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     502            psFree(md);
     503            exit(EXIT_FAILURE);
     504        }
     505        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     506            psFree(md);
     507            exit(EXIT_FAILURE);
     508        }
     509        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
     510            psFree(md);
     511            exit(EXIT_FAILURE);
     512        }
     513        if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
     514            psFree(md);
     515            exit(EXIT_FAILURE);
     516        }
     517        if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
     518            psFree(md);
     519            exit(EXIT_FAILURE);
     520        }
     521        if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    180522            psFree(md);
    181523            exit(EXIT_FAILURE);
    … …  
    189531            exit(EXIT_FAILURE);
    190532        }
    191         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exptime", 0, NULL, 32.32)) {
    192             psFree(md);
    193             exit(EXIT_FAILURE);
    194         }
    195         if (!psMetadataAddF64(md, PS_LIST_TAIL, "sky_bright", 0, NULL, 64.64)) {
    196             psFree(md);
    197             exit(EXIT_FAILURE);
    198         }
    199 
    200         object = skyp_absorptionObjectFromMetadata(md);
    201         if (!object) {
    202             psFree(md);
    203             exit(EXIT_FAILURE);
    204         }
    205 
    206         psFree(md);
    207 
    208         if (strncmp(object->disperser_id, "a string", MAX_STRING_LENGTH)) {
    209             psFree(object);
    210             exit(EXIT_FAILURE);
    211         }
    212         if (!object->atmcomp1 == 32.32) {
    213             psFree(object);
    214             exit(EXIT_FAILURE);
    215         }
    216         if (!object->atmcomp2 == 32.32) {
    217             psFree(object);
    218             exit(EXIT_FAILURE);
    219         }
    220         if (!object->atmcomp3 == 32.32) {
    221             psFree(object);
    222             exit(EXIT_FAILURE);
    223         }
    224         if (!object->nstars == -32) {
     533        if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
     534            psFree(md);
     535            exit(EXIT_FAILURE);
     536        }
     537        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
     538            psFree(md);
     539            exit(EXIT_FAILURE);
     540        }
     541        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
     542            psFree(md);
     543            exit(EXIT_FAILURE);
     544        }
     545        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     546            psFree(md);
     547            exit(EXIT_FAILURE);
     548        }
     549        if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
     550            psFree(md);
     551            exit(EXIT_FAILURE);
     552        }
     553        if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
     554            psFree(md);
     555            exit(EXIT_FAILURE);
     556        }
     557        if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
     558            psFree(md);
     559            exit(EXIT_FAILURE);
     560        }
     561        if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
     562            psFree(md);
     563            exit(EXIT_FAILURE);
     564        }
     565        if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
     566            psFree(md);
     567            exit(EXIT_FAILURE);
     568        }
     569            psFree(md);
     570            exit(EXIT_FAILURE);
     571        }
     572
     573        object = rawScienceExpObjectFromMetadata(md);
     574        if (!object) {
     575            psFree(md);
     576            exit(EXIT_FAILURE);
     577        }
     578
     579        psFree(md);
     580
     581        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     582            psFree(object);
     583            exit(EXIT_FAILURE);
     584        }
     585        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     586            psFree(object);
     587            exit(EXIT_FAILURE);
     588        }
     589        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     590            psFree(object);
     591            exit(EXIT_FAILURE);
     592        }
     593        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     594            psFree(object);
     595            exit(EXIT_FAILURE);
     596        }
     597        if (!object->imfiles == -32) {
     598            psFree(object);
     599            exit(EXIT_FAILURE);
     600        }
     601        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     602            psFree(object);
     603            exit(EXIT_FAILURE);
     604        }
     605        if (!object->airmass == 32.32) {
    225606            psFree(object);
    226607            exit(EXIT_FAILURE);
    … …  
    234615            exit(EXIT_FAILURE);
    235616        }
    236         if (!object->exptime == 32.32) {
    237             psFree(object);
    238             exit(EXIT_FAILURE);
    239         }
    240         if (!object->sky_bright == 64.64) {
    241             psFree(object);
    242             exit(EXIT_FAILURE);
    243         }
    244 
    245         psFree(object);
    246     }
    247 
    248     {
    249         psMetadata      *md;
    250         skyp_emissionRow *object;
    251 
    252         md = psMetadataAlloc();
    253         if (!psMetadataAddStr(md, PS_LIST_TAIL, "disperser_id", 0, NULL, "a string")) {
    254             psFree(md);
    255             exit(EXIT_FAILURE);
    256         }
    257         if (!psMetadataAddF32(md, PS_LIST_TAIL, "atmcomp1", 0, NULL, 32.32)) {
    258             psFree(md);
    259             exit(EXIT_FAILURE);
    260         }
    261         if (!psMetadataAddF32(md, PS_LIST_TAIL, "atmcomp2", 0, NULL, 32.32)) {
    262             psFree(md);
    263             exit(EXIT_FAILURE);
    264         }
    265         if (!psMetadataAddF32(md, PS_LIST_TAIL, "atmcomp3", 0, NULL, 32.32)) {
    266             psFree(md);
    267             exit(EXIT_FAILURE);
    268         }
    269         if (!psMetadataAddF32(md, PS_LIST_TAIL, "continuum", 0, NULL, 32.32)) {
    270             psFree(md);
    271             exit(EXIT_FAILURE);
    272         }
    273         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exptime", 0, NULL, 32.32)) {
    274             psFree(md);
    275             exit(EXIT_FAILURE);
    276         }
    277 
    278         object = skyp_emissionObjectFromMetadata(md);
    279         if (!object) {
    280             psFree(md);
    281             exit(EXIT_FAILURE);
    282         }
    283 
    284         psFree(md);
    285 
    286         if (strncmp(object->disperser_id, "a string", MAX_STRING_LENGTH)) {
    287             psFree(object);
    288             exit(EXIT_FAILURE);
    289         }
    290         if (!object->atmcomp1 == 32.32) {
    291             psFree(object);
    292             exit(EXIT_FAILURE);
    293         }
    294         if (!object->atmcomp2 == 32.32) {
    295             psFree(object);
    296             exit(EXIT_FAILURE);
    297         }
    298         if (!object->atmcomp3 == 32.32) {
    299             psFree(object);
    300             exit(EXIT_FAILURE);
    301         }
    302         if (!object->continuum == 32.32) {
    303             psFree(object);
    304             exit(EXIT_FAILURE);
    305         }
    306         if (!object->exptime == 32.32) {
    307             psFree(object);
    308             exit(EXIT_FAILURE);
    309         }
    310 
    311         psFree(object);
    312     }
    313 
    314     {
    315         psMetadata      *md;
    316         dimmRow         *object;
    317 
    318         md = psMetadataAlloc();
    319         if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigmax", 0, NULL, 32.32)) {
    320             psFree(md);
    321             exit(EXIT_FAILURE);
    322         }
    323         if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigmay", 0, NULL, 32.32)) {
    324             psFree(md);
    325             exit(EXIT_FAILURE);
    326         }
    327         if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm", 0, NULL, 32.32)) {
     617        if (!object->exp_time == 32.32) {
     618            psFree(object);
     619            exit(EXIT_FAILURE);
     620        }
     621        if (!object->bg == 64.64) {
     622            psFree(object);
     623            exit(EXIT_FAILURE);
     624        }
     625        if (!object->bg_stdev == 64.64) {
     626            psFree(object);
     627            exit(EXIT_FAILURE);
     628        }
     629        if (!object->bg_mean_stdev == 64.64) {
     630            psFree(object);
     631            exit(EXIT_FAILURE);
     632        }
     633        if (!object->alt == 64.64) {
     634            psFree(object);
     635            exit(EXIT_FAILURE);
     636        }
     637        if (!object->az == 64.64) {
     638            psFree(object);
     639            exit(EXIT_FAILURE);
     640        }
     641        if (!object->ccd_temp == 32.32) {
     642            psFree(object);
     643            exit(EXIT_FAILURE);
     644        }
     645        if (!object->posang == 64.64) {
     646            psFree(object);
     647            exit(EXIT_FAILURE);
     648        }
     649        if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
     650            psFree(object);
     651            exit(EXIT_FAILURE);
     652        }
     653            psFree(object);
     654            exit(EXIT_FAILURE);
     655        }
     656
     657        psFree(object);
     658    }
     659
     660    {
     661        psMetadata      *md;
     662        rawImfileRow    *object;
     663
     664        md = psMetadataAlloc();
     665        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     666            psFree(md);
     667            exit(EXIT_FAILURE);
     668        }
     669        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     670            psFree(md);
     671            exit(EXIT_FAILURE);
     672        }
     673        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     674            psFree(md);
     675            exit(EXIT_FAILURE);
     676        }
     677        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     678            psFree(md);
     679            exit(EXIT_FAILURE);
     680        }
     681        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
     682            psFree(md);
     683            exit(EXIT_FAILURE);
     684        }
     685        if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
     686            psFree(md);
     687            exit(EXIT_FAILURE);
     688        }
     689        if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    328690            psFree(md);
    329691            exit(EXIT_FAILURE);
    … …  
    337699            exit(EXIT_FAILURE);
    338700        }
    339         if (!psMetadataAddF32(md, PS_LIST_TAIL, "expttime", 0, NULL, 32.32)) {
    340             psFree(md);
    341             exit(EXIT_FAILURE);
    342         }
    343         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope_id", 0, NULL, "a string")) {
    344             psFree(md);
    345             exit(EXIT_FAILURE);
    346         }
    347 
    348         object = dimmObjectFromMetadata(md);
    349         if (!object) {
    350             psFree(md);
    351             exit(EXIT_FAILURE);
    352         }
    353 
    354         psFree(md);
    355 
    356         if (!object->sigmax == 32.32) {
    357             psFree(object);
    358             exit(EXIT_FAILURE);
    359         }
    360         if (!object->sigmay == 32.32) {
    361             psFree(object);
    362             exit(EXIT_FAILURE);
    363         }
    364         if (!object->fwhm == 32.32) {
     701        if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
     702            psFree(md);
     703            exit(EXIT_FAILURE);
     704        }
     705        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
     706            psFree(md);
     707            exit(EXIT_FAILURE);
     708        }
     709        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
     710            psFree(md);
     711            exit(EXIT_FAILURE);
     712        }
     713        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     714            psFree(md);
     715            exit(EXIT_FAILURE);
     716        }
     717        if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
     718            psFree(md);
     719            exit(EXIT_FAILURE);
     720        }
     721        if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
     722            psFree(md);
     723            exit(EXIT_FAILURE);
     724        }
     725        if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
     726            psFree(md);
     727            exit(EXIT_FAILURE);
     728        }
     729        if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
     730            psFree(md);
     731            exit(EXIT_FAILURE);
     732        }
     733        if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
     734            psFree(md);
     735            exit(EXIT_FAILURE);
     736        }
     737            psFree(md);
     738            exit(EXIT_FAILURE);
     739        }
     740
     741        object = rawImfileObjectFromMetadata(md);
     742        if (!object) {
     743            psFree(md);
     744            exit(EXIT_FAILURE);
     745        }
     746
     747        psFree(md);
     748
     749        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     750            psFree(object);
     751            exit(EXIT_FAILURE);
     752        }
     753        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     754            psFree(object);
     755            exit(EXIT_FAILURE);
     756        }
     757        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     758            psFree(object);
     759            exit(EXIT_FAILURE);
     760        }
     761        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     762            psFree(object);
     763            exit(EXIT_FAILURE);
     764        }
     765        if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
     766            psFree(object);
     767            exit(EXIT_FAILURE);
     768        }
     769        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     770            psFree(object);
     771            exit(EXIT_FAILURE);
     772        }
     773        if (!object->airmass == 32.32) {
    365774            psFree(object);
    366775            exit(EXIT_FAILURE);
    … …  
    374783            exit(EXIT_FAILURE);
    375784        }
    376         if (!object->expttime == 32.32) {
    377             psFree(object);
    378             exit(EXIT_FAILURE);
    379         }
    380         if (strncmp(object->telescope_id, "a string", MAX_STRING_LENGTH)) {
    381             psFree(object);
    382             exit(EXIT_FAILURE);
    383         }
    384 
    385         psFree(object);
    386     }
    387 
    388     {
    389         psMetadata      *md;
    390         skyp_irRow      *object;
    391 
    392         md = psMetadataAlloc();
    393         if (!psMetadataAddF64(md, PS_LIST_TAIL, "sky_bright", 0, NULL, 64.64)) {
    394             psFree(md);
    395             exit(EXIT_FAILURE);
    396         }
    397         if (!psMetadataAddF64(md, PS_LIST_TAIL, "sky_var", 0, NULL, 64.64)) {
    398             psFree(md);
    399             exit(EXIT_FAILURE);
    400         }
    401         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    402             psFree(md);
    403             exit(EXIT_FAILURE);
    404         }
    405         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    406             psFree(md);
    407             exit(EXIT_FAILURE);
    408         }
    409         if (!psMetadataAddF32(md, PS_LIST_TAIL, "fov_x", 0, NULL, 32.32)) {
    410             psFree(md);
    411             exit(EXIT_FAILURE);
    412         }
    413         if (!psMetadataAddF32(md, PS_LIST_TAIL, "fov_y", 0, NULL, 32.32)) {
    414             psFree(md);
    415             exit(EXIT_FAILURE);
    416         }
    417 
    418         object = skyp_irObjectFromMetadata(md);
    419         if (!object) {
    420             psFree(md);
    421             exit(EXIT_FAILURE);
    422         }
    423 
    424         psFree(md);
    425 
    426         if (!object->sky_bright == 64.64) {
    427             psFree(object);
    428             exit(EXIT_FAILURE);
    429         }
    430         if (!object->sky_var == 64.64) {
    431             psFree(object);
    432             exit(EXIT_FAILURE);
    433         }
    434         if (!object->ra == 64.64) {
    435             psFree(object);
    436             exit(EXIT_FAILURE);
    437         }
    438         if (!object->decl == 64.64) {
    439             psFree(object);
    440             exit(EXIT_FAILURE);
    441         }
    442         if (!object->fov_x == 32.32) {
    443             psFree(object);
    444             exit(EXIT_FAILURE);
    445         }
    446         if (!object->fov_y == 32.32) {
    447             psFree(object);
    448             exit(EXIT_FAILURE);
    449         }
    450 
    451         psFree(object);
    452     }
    453 
    454     {
    455         psMetadata      *md;
    456         domeRow         *object;
    457 
    458         md = psMetadataAlloc();
    459         if (!psMetadataAddF32(md, PS_LIST_TAIL, "az", 0, NULL, 32.32)) {
    460             psFree(md);
    461             exit(EXIT_FAILURE);
    462         }
    463         if (!psMetadataAdd(md, PS_LIST_TAIL, "open", PS_DATA_BOOL, NULL, true)) {
    464             psFree(md);
    465             exit(EXIT_FAILURE);
    466         }
    467         if (!psMetadataAdd(md, PS_LIST_TAIL, "light", PS_DATA_BOOL, NULL, true)) {
    468             psFree(md);
    469             exit(EXIT_FAILURE);
    470         }
    471         if (!psMetadataAdd(md, PS_LIST_TAIL, "track", PS_DATA_BOOL, NULL, true)) {
    472             psFree(md);
    473             exit(EXIT_FAILURE);
    474         }
    475 
    476         object = domeObjectFromMetadata(md);
    477         if (!object) {
    478             psFree(md);
    479             exit(EXIT_FAILURE);
    480         }
    481 
    482         psFree(md);
    483 
    484         if (!object->az == 32.32) {
    485             psFree(object);
    486             exit(EXIT_FAILURE);
    487         }
    488         if (!object->open == true) {
    489             psFree(object);
    490             exit(EXIT_FAILURE);
    491         }
    492         if (!object->light == true) {
    493             psFree(object);
    494             exit(EXIT_FAILURE);
    495         }
    496         if (!object->track == true) {
    497             psFree(object);
    498             exit(EXIT_FAILURE);
    499         }
    500 
    501         psFree(object);
    502     }
    503 
    504     {
    505         psMetadata      *md;
    506         telescopeRow    *object;
    507 
    508         md = psMetadataAlloc();
    509         if (!psMetadataAddStr(md, PS_LIST_TAIL, "guide", 0, NULL, "a string")) {
    510             psFree(md);
    511             exit(EXIT_FAILURE);
    512         }
    513         if (!psMetadataAddF32(md, PS_LIST_TAIL, "alt", 0, NULL, 32.32)) {
    514             psFree(md);
    515             exit(EXIT_FAILURE);
    516         }
    517         if (!psMetadataAddF32(md, PS_LIST_TAIL, "az", 0, NULL, 32.32)) {
    518             psFree(md);
    519             exit(EXIT_FAILURE);
    520         }
    521         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    522             psFree(md);
    523             exit(EXIT_FAILURE);
    524         }
    525         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    526             psFree(md);
    527             exit(EXIT_FAILURE);
    528         }
    529 
    530         object = telescopeObjectFromMetadata(md);
    531         if (!object) {
    532             psFree(md);
    533             exit(EXIT_FAILURE);
    534         }
    535 
    536         psFree(md);
    537 
    538         if (strncmp(object->guide, "a string", MAX_STRING_LENGTH)) {
    539             psFree(object);
    540             exit(EXIT_FAILURE);
    541         }
    542         if (!object->alt == 32.32) {
    543             psFree(object);
    544             exit(EXIT_FAILURE);
    545         }
    546         if (!object->az == 32.32) {
    547             psFree(object);
    548             exit(EXIT_FAILURE);
    549         }
    550         if (!object->ra == 64.64) {
    551             psFree(object);
    552             exit(EXIT_FAILURE);
    553         }
    554         if (!object->decl == 64.64) {
    555             psFree(object);
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psFree(object);
    560     }
    561 
    562     {
    563         psMetadata      *md;
    564         summitExpRow    *object;
    565 
    566         md = psMetadataAlloc();
    567         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
    568             psFree(md);
    569             exit(EXIT_FAILURE);
    570         }
    571         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    572             psFree(md);
    573             exit(EXIT_FAILURE);
    574         }
    575         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    576             psFree(md);
    577             exit(EXIT_FAILURE);
    578         }
    579         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    580             psFree(md);
    581             exit(EXIT_FAILURE);
    582         }
    583         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    584             psFree(md);
    585             exit(EXIT_FAILURE);
    586         }
    587 
    588         object = summitExpObjectFromMetadata(md);
    589         if (!object) {
    590             psFree(md);
    591             exit(EXIT_FAILURE);
    592         }
    593 
    594         psFree(md);
    595 
    596         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    597             psFree(object);
    598             exit(EXIT_FAILURE);
    599         }
    600         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    601             psFree(object);
    602             exit(EXIT_FAILURE);
    603         }
    604         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    605             psFree(object);
    606             exit(EXIT_FAILURE);
    607         }
    608         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    609             psFree(object);
    610             exit(EXIT_FAILURE);
    611         }
    612         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    613             psFree(object);
    614             exit(EXIT_FAILURE);
    615         }
    616 
    617         psFree(object);
    618     }
    619 
    620     {
    621         psMetadata      *md;
    622         pzPendingExpRow *object;
    623 
    624         md = psMetadataAlloc();
    625         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
    626             psFree(md);
    627             exit(EXIT_FAILURE);
    628         }
    629         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    630             psFree(md);
    631             exit(EXIT_FAILURE);
    632         }
    633         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    634             psFree(md);
    635             exit(EXIT_FAILURE);
    636         }
    637         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    638             psFree(md);
    639             exit(EXIT_FAILURE);
    640         }
    641         if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
    642             psFree(md);
    643             exit(EXIT_FAILURE);
    644         }
    645 
    646         object = pzPendingExpObjectFromMetadata(md);
    647         if (!object) {
    648             psFree(md);
    649             exit(EXIT_FAILURE);
    650         }
    651 
    652         psFree(md);
    653 
    654         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    655             psFree(object);
    656             exit(EXIT_FAILURE);
    657         }
    658         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    659             psFree(object);
    660             exit(EXIT_FAILURE);
    661         }
    662         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    663             psFree(object);
    664             exit(EXIT_FAILURE);
    665         }
    666         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    667             psFree(object);
    668             exit(EXIT_FAILURE);
    669         }
    670         if (!object->imfiles == -32) {
    671             psFree(object);
    672             exit(EXIT_FAILURE);
    673         }
    674 
    675         psFree(object);
    676     }
    677 
    678     {
    679         psMetadata      *md;
    680         pzPendingImfileRow *object;
    681 
    682         md = psMetadataAlloc();
    683         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
    684             psFree(md);
    685             exit(EXIT_FAILURE);
    686         }
    687         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    688             psFree(md);
    689             exit(EXIT_FAILURE);
    690         }
    691         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    692             psFree(md);
    693             exit(EXIT_FAILURE);
    694         }
    695         if (!psMetadataAddS32(md, PS_LIST_TAIL, "bytes", 0, NULL, -32)) {
    696             psFree(md);
    697             exit(EXIT_FAILURE);
    698         }
    699         if (!psMetadataAddStr(md, PS_LIST_TAIL, "md5sum", 0, NULL, "a string")) {
    700             psFree(md);
    701             exit(EXIT_FAILURE);
    702         }
    703         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
    704             psFree(md);
    705             exit(EXIT_FAILURE);
    706         }
    707         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    708             psFree(md);
    709             exit(EXIT_FAILURE);
    710         }
    711         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    712             psFree(md);
    713             exit(EXIT_FAILURE);
    714         }
    715 
    716         object = pzPendingImfileObjectFromMetadata(md);
    717         if (!object) {
    718             psFree(md);
    719             exit(EXIT_FAILURE);
    720         }
    721 
    722         psFree(md);
    723 
    724         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    725             psFree(object);
    726             exit(EXIT_FAILURE);
    727         }
    728         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    729             psFree(object);
    730             exit(EXIT_FAILURE);
    731         }
    732         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    733             psFree(object);
    734             exit(EXIT_FAILURE);
    735         }
    736         if (!object->bytes == -32) {
    737             psFree(object);
    738             exit(EXIT_FAILURE);
    739         }
    740         if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
    741             psFree(object);
    742             exit(EXIT_FAILURE);
    743         }
    744         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    745             psFree(object);
    746             exit(EXIT_FAILURE);
    747         }
    748         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    749             psFree(object);
    750             exit(EXIT_FAILURE);
    751         }
    752         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    753             psFree(object);
    754             exit(EXIT_FAILURE);
    755         }
    756 
    757         psFree(object);
    758     }
    759 
    760     {
    761         psMetadata      *md;
    762         newExpRow       *object;
    763 
    764         md = psMetadataAlloc();
    765         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    766             psFree(md);
    767             exit(EXIT_FAILURE);
    768         }
    769         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
    770             psFree(md);
    771             exit(EXIT_FAILURE);
    772         }
    773         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    774             psFree(md);
    775             exit(EXIT_FAILURE);
    776         }
    777         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    778             psFree(md);
    779             exit(EXIT_FAILURE);
    780         }
    781         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    782             psFree(md);
    783             exit(EXIT_FAILURE);
    784         }
    785         if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
    786             psFree(md);
    787             exit(EXIT_FAILURE);
    788         }
    789 
    790         object = newExpObjectFromMetadata(md);
    791         if (!object) {
    792             psFree(md);
    793             exit(EXIT_FAILURE);
    794         }
    795 
    796         psFree(md);
    797 
    798         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    799             psFree(object);
    800             exit(EXIT_FAILURE);
    801         }
    802         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    803             psFree(object);
    804             exit(EXIT_FAILURE);
    805         }
    806         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    807             psFree(object);
    808             exit(EXIT_FAILURE);
    809         }
    810         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    811             psFree(object);
    812             exit(EXIT_FAILURE);
    813         }
    814         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    815             psFree(object);
    816             exit(EXIT_FAILURE);
    817         }
    818         if (!object->imfiles == -32) {
    819             psFree(object);
    820             exit(EXIT_FAILURE);
    821         }
    822 
    823         psFree(object);
    824     }
    825 
    826     {
    827         psMetadata      *md;
    828         newImfileRow    *object;
    829 
    830         md = psMetadataAlloc();
    831         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    832             psFree(md);
    833             exit(EXIT_FAILURE);
    834         }
    835         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
    836             psFree(md);
    837             exit(EXIT_FAILURE);
    838         }
    839         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    840             psFree(md);
    841             exit(EXIT_FAILURE);
    842         }
    843         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    844             psFree(md);
    845             exit(EXIT_FAILURE);
    846         }
    847 
    848         object = newImfileObjectFromMetadata(md);
    849         if (!object) {
    850             psFree(md);
    851             exit(EXIT_FAILURE);
    852         }
    853 
    854         psFree(md);
    855 
    856         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    857             psFree(object);
    858             exit(EXIT_FAILURE);
    859         }
    860         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    861             psFree(object);
    862             exit(EXIT_FAILURE);
    863         }
    864         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    865             psFree(object);
    866             exit(EXIT_FAILURE);
    867         }
    868         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    869             psFree(object);
    870             exit(EXIT_FAILURE);
    871         }
    872 
    873         psFree(object);
    874     }
    875 
    876     {
    877         psMetadata      *md;
    878         rawDetrendExpRow *object;
    879 
    880         md = psMetadataAlloc();
    881         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    882             psFree(md);
    883             exit(EXIT_FAILURE);
    884         }
    885         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    886             psFree(md);
    887             exit(EXIT_FAILURE);
    888         }
    889         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    890             psFree(md);
    891             exit(EXIT_FAILURE);
    892         }
    893         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    894             psFree(md);
    895             exit(EXIT_FAILURE);
    896         }
    897         if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
    898             psFree(md);
    899             exit(EXIT_FAILURE);
    900         }
    901         if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
    902             psFree(md);
    903             exit(EXIT_FAILURE);
    904         }
    905         if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    906             psFree(md);
    907             exit(EXIT_FAILURE);
    908         }
    909         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    910             psFree(md);
    911             exit(EXIT_FAILURE);
    912         }
    913         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    914             psFree(md);
    915             exit(EXIT_FAILURE);
    916         }
    917         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
    918             psFree(md);
    919             exit(EXIT_FAILURE);
    920         }
    921         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    922             psFree(md);
    923             exit(EXIT_FAILURE);
    924         }
    925         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
    926             psFree(md);
    927             exit(EXIT_FAILURE);
    928         }
    929         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
    930             psFree(md);
    931             exit(EXIT_FAILURE);
    932         }
    933         if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
    934             psFree(md);
    935             exit(EXIT_FAILURE);
    936         }
    937         if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
    938             psFree(md);
    939             exit(EXIT_FAILURE);
    940         }
    941         if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
    942             psFree(md);
    943             exit(EXIT_FAILURE);
    944         }
    945         if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
    946             psFree(md);
    947             exit(EXIT_FAILURE);
    948         }
    949         if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
    950             psFree(md);
    951             exit(EXIT_FAILURE);
    952         }
    953 
    954         object = rawDetrendExpObjectFromMetadata(md);
    955         if (!object) {
    956             psFree(md);
    957             exit(EXIT_FAILURE);
    958         }
    959 
    960         psFree(md);
    961 
    962         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    963             psFree(object);
    964             exit(EXIT_FAILURE);
    965         }
    966         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    967             psFree(object);
    968             exit(EXIT_FAILURE);
    969         }
    970         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    971             psFree(object);
    972             exit(EXIT_FAILURE);
    973         }
    974         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    975             psFree(object);
    976             exit(EXIT_FAILURE);
    977         }
    978         if (!object->imfiles == -32) {
    979             psFree(object);
    980             exit(EXIT_FAILURE);
    981         }
    982         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    983             psFree(object);
    984             exit(EXIT_FAILURE);
    985         }
    986         if (!object->airmass == 32.32) {
    987             psFree(object);
    988             exit(EXIT_FAILURE);
    989         }
    990         if (!object->ra == 64.64) {
    991             psFree(object);
    992             exit(EXIT_FAILURE);
    993         }
    994         if (!object->decl == 64.64) {
    995             psFree(object);
    996             exit(EXIT_FAILURE);
    997         }
    998785        if (!object->exp_time == 32.32) {
    999786            psFree(object);
    … …  
    1032819            exit(EXIT_FAILURE);
    1033820        }
    1034 
    1035         psFree(object);
    1036     }
    1037 
    1038     {
    1039         psMetadata      *md;
    1040         rawScienceExpRow *object;
    1041 
    1042         md = psMetadataAlloc();
    1043         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    1044             psFree(md);
    1045             exit(EXIT_FAILURE);
    1046         }
    1047         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    1048             psFree(md);
    1049             exit(EXIT_FAILURE);
    1050         }
    1051         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    1052             psFree(md);
    1053             exit(EXIT_FAILURE);
    1054         }
    1055         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    1056             psFree(md);
    1057             exit(EXIT_FAILURE);
    1058         }
    1059         if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
    1060             psFree(md);
    1061             exit(EXIT_FAILURE);
    1062         }
    1063         if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
    1064             psFree(md);
    1065             exit(EXIT_FAILURE);
    1066         }
    1067         if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    1068             psFree(md);
    1069             exit(EXIT_FAILURE);
    1070         }
    1071         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    1072             psFree(md);
    1073             exit(EXIT_FAILURE);
    1074         }
    1075         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    1076             psFree(md);
    1077             exit(EXIT_FAILURE);
    1078         }
    1079         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
    1080             psFree(md);
    1081             exit(EXIT_FAILURE);
    1082         }
    1083         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    1084             psFree(md);
    1085             exit(EXIT_FAILURE);
    1086         }
    1087         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
    1088             psFree(md);
    1089             exit(EXIT_FAILURE);
    1090         }
    1091         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
    1092             psFree(md);
    1093             exit(EXIT_FAILURE);
    1094         }
    1095         if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
    1096             psFree(md);
    1097             exit(EXIT_FAILURE);
    1098         }
    1099         if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
    1100             psFree(md);
    1101             exit(EXIT_FAILURE);
    1102         }
    1103         if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
    1104             psFree(md);
    1105             exit(EXIT_FAILURE);
    1106         }
    1107         if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
    1108             psFree(md);
    1109             exit(EXIT_FAILURE);
    1110         }
    1111         if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
    1112             psFree(md);
    1113             exit(EXIT_FAILURE);
    1114         }
    1115 
    1116         object = rawScienceExpObjectFromMetadata(md);
    1117         if (!object) {
    1118             psFree(md);
    1119             exit(EXIT_FAILURE);
    1120         }
    1121 
    1122         psFree(md);
    1123 
    1124         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1125             psFree(object);
    1126             exit(EXIT_FAILURE);
    1127         }
    1128         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    1129             psFree(object);
    1130             exit(EXIT_FAILURE);
    1131         }
    1132         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    1133             psFree(object);
    1134             exit(EXIT_FAILURE);
    1135         }
    1136         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    1137             psFree(object);
    1138             exit(EXIT_FAILURE);
    1139         }
    1140         if (!object->imfiles == -32) {
    1141             psFree(object);
    1142             exit(EXIT_FAILURE);
    1143         }
    1144         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    1145             psFree(object);
    1146             exit(EXIT_FAILURE);
    1147         }
    1148         if (!object->airmass == 32.32) {
    1149             psFree(object);
    1150             exit(EXIT_FAILURE);
    1151         }
    1152         if (!object->ra == 64.64) {
    1153             psFree(object);
    1154             exit(EXIT_FAILURE);
    1155         }
    1156         if (!object->decl == 64.64) {
    1157             psFree(object);
    1158             exit(EXIT_FAILURE);
    1159         }
    1160         if (!object->exp_time == 32.32) {
    1161             psFree(object);
    1162             exit(EXIT_FAILURE);
    1163         }
    1164         if (!object->bg == 64.64) {
    1165             psFree(object);
    1166             exit(EXIT_FAILURE);
    1167         }
    1168         if (!object->bg_stdev == 64.64) {
    1169             psFree(object);
    1170             exit(EXIT_FAILURE);
    1171         }
    1172         if (!object->bg_mean_stdev == 64.64) {
    1173             psFree(object);
    1174             exit(EXIT_FAILURE);
    1175         }
    1176         if (!object->alt == 64.64) {
    1177             psFree(object);
    1178             exit(EXIT_FAILURE);
    1179         }
    1180         if (!object->az == 64.64) {
    1181             psFree(object);
    1182             exit(EXIT_FAILURE);
    1183         }
    1184         if (!object->ccd_temp == 32.32) {
    1185             psFree(object);
    1186             exit(EXIT_FAILURE);
    1187         }
    1188         if (!object->posang == 64.64) {
    1189             psFree(object);
    1190             exit(EXIT_FAILURE);
    1191         }
    1192         if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
    1193             psFree(object);
    1194             exit(EXIT_FAILURE);
    1195         }
    1196 
    1197         psFree(object);
    1198     }
    1199 
    1200     {
    1201         psMetadata      *md;
    1202         rawImfileRow    *object;
    1203 
    1204         md = psMetadataAlloc();
    1205         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    1206             psFree(md);
    1207             exit(EXIT_FAILURE);
    1208         }
    1209         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
    1210             psFree(md);
    1211             exit(EXIT_FAILURE);
    1212         }
    1213         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    1214             psFree(md);
    1215             exit(EXIT_FAILURE);
    1216         }
    1217         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    1218             psFree(md);
    1219             exit(EXIT_FAILURE);
    1220         }
    1221         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    1222             psFree(md);
    1223             exit(EXIT_FAILURE);
    1224         }
    1225         if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
    1226             psFree(md);
    1227             exit(EXIT_FAILURE);
    1228         }
    1229         if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    1230             psFree(md);
    1231             exit(EXIT_FAILURE);
    1232         }
    1233         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    1234             psFree(md);
    1235             exit(EXIT_FAILURE);
    1236         }
    1237         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    1238             psFree(md);
    1239             exit(EXIT_FAILURE);
    1240         }
    1241         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
    1242             psFree(md);
    1243             exit(EXIT_FAILURE);
    1244         }
    1245         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    1246             psFree(md);
    1247             exit(EXIT_FAILURE);
    1248         }
    1249         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
    1250             psFree(md);
    1251             exit(EXIT_FAILURE);
    1252         }
    1253         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
    1254             psFree(md);
    1255             exit(EXIT_FAILURE);
    1256         }
    1257         if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
    1258             psFree(md);
    1259             exit(EXIT_FAILURE);
    1260         }
    1261         if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
    1262             psFree(md);
    1263             exit(EXIT_FAILURE);
    1264         }
    1265         if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
    1266             psFree(md);
    1267             exit(EXIT_FAILURE);
    1268         }
    1269         if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
    1270             psFree(md);
    1271             exit(EXIT_FAILURE);
    1272         }
    1273         if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
    1274             psFree(md);
    1275             exit(EXIT_FAILURE);
    1276         }
    1277 
    1278         object = rawImfileObjectFromMetadata(md);
    1279         if (!object) {
    1280             psFree(md);
    1281             exit(EXIT_FAILURE);
    1282         }
    1283 
    1284         psFree(md);
    1285 
    1286         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1287             psFree(object);
    1288             exit(EXIT_FAILURE);
    1289         }
    1290         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    1291             psFree(object);
    1292             exit(EXIT_FAILURE);
    1293         }
    1294         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    1295             psFree(object);
    1296             exit(EXIT_FAILURE);
    1297         }
    1298         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    1299             psFree(object);
    1300             exit(EXIT_FAILURE);
    1301         }
    1302         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    1303             psFree(object);
    1304             exit(EXIT_FAILURE);
    1305         }
    1306         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    1307             psFree(object);
    1308             exit(EXIT_FAILURE);
    1309         }
    1310         if (!object->airmass == 32.32) {
    1311             psFree(object);
    1312             exit(EXIT_FAILURE);
    1313         }
    1314         if (!object->ra == 64.64) {
    1315             psFree(object);
    1316             exit(EXIT_FAILURE);
    1317         }
    1318         if (!object->decl == 64.64) {
    1319             psFree(object);
    1320             exit(EXIT_FAILURE);
    1321         }
    1322         if (!object->exp_time == 32.32) {
    1323             psFree(object);
    1324             exit(EXIT_FAILURE);
    1325         }
    1326         if (!object->bg == 64.64) {
    1327             psFree(object);
    1328             exit(EXIT_FAILURE);
    1329         }
    1330         if (!object->bg_stdev == 64.64) {
    1331             psFree(object);
    1332             exit(EXIT_FAILURE);
    1333         }
    1334         if (!object->bg_mean_stdev == 64.64) {
    1335             psFree(object);
    1336             exit(EXIT_FAILURE);
    1337         }
    1338         if (!object->alt == 64.64) {
    1339             psFree(object);
    1340             exit(EXIT_FAILURE);
    1341         }
    1342         if (!object->az == 64.64) {
    1343             psFree(object);
    1344             exit(EXIT_FAILURE);
    1345         }
    1346         if (!object->ccd_temp == 32.32) {
    1347             psFree(object);
    1348             exit(EXIT_FAILURE);
    1349         }
    1350         if (!object->posang == 64.64) {
    1351             psFree(object);
    1352             exit(EXIT_FAILURE);
    1353         }
    1354         if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
    1355821            psFree(object);
    1356822            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/selectrowsfits.c

    r9301 r9684  
    2121        }
    2222
    23         if (!weatherSelectRowsFits(dbh, fits, NULL, 1)) {
    24             exit(EXIT_FAILURE);
    25         }
    26 
    27         psFree(fits);
    28         psDBCleanup(dbh);
    29     }
    30 
    31     {
    32         psDB            *dbh;
    33         psFits          *fits;
    34 
    35         dbh = psDBInit("localhost", "test", NULL, "test");
    36         if (!dbh) {
    37             exit(EXIT_FAILURE);
    38         }
    39 
    40         fits = psFitsOpen(TMP_FILENAME, "w");
    41         if (!fits) {
    42             exit(EXIT_FAILURE);
    43         }
    44 
    45         if (!skyp_transparencySelectRowsFits(dbh, fits, NULL, 1)) {
    46             exit(EXIT_FAILURE);
    47         }
    48 
    49         psFree(fits);
    50         psDBCleanup(dbh);
    51     }
    52 
    53     {
    54         psDB            *dbh;
    55         psFits          *fits;
    56 
    57         dbh = psDBInit("localhost", "test", NULL, "test");
    58         if (!dbh) {
    59             exit(EXIT_FAILURE);
    60         }
    61 
    62         fits = psFitsOpen(TMP_FILENAME, "w");
    63         if (!fits) {
    64             exit(EXIT_FAILURE);
    65         }
    66 
    67         if (!skyp_absorptionSelectRowsFits(dbh, fits, NULL, 1)) {
    68             exit(EXIT_FAILURE);
    69         }
    70 
    71         psFree(fits);
    72         psDBCleanup(dbh);
    73     }
    74 
    75     {
    76         psDB            *dbh;
    77         psFits          *fits;
    78 
    79         dbh = psDBInit("localhost", "test", NULL, "test");
    80         if (!dbh) {
    81             exit(EXIT_FAILURE);
    82         }
    83 
    84         fits = psFitsOpen(TMP_FILENAME, "w");
    85         if (!fits) {
    86             exit(EXIT_FAILURE);
    87         }
    88 
    89         if (!skyp_emissionSelectRowsFits(dbh, fits, NULL, 1)) {
    90             exit(EXIT_FAILURE);
    91         }
    92 
    93         psFree(fits);
    94         psDBCleanup(dbh);
    95     }
    96 
    97     {
    98         psDB            *dbh;
    99         psFits          *fits;
    100 
    101         dbh = psDBInit("localhost", "test", NULL, "test");
    102         if (!dbh) {
    103             exit(EXIT_FAILURE);
    104         }
    105 
    106         fits = psFitsOpen(TMP_FILENAME, "w");
    107         if (!fits) {
    108             exit(EXIT_FAILURE);
    109         }
    110 
    111         if (!dimmSelectRowsFits(dbh, fits, NULL, 1)) {
    112             exit(EXIT_FAILURE);
    113         }
    114 
    115         psFree(fits);
    116         psDBCleanup(dbh);
    117     }
    118 
    119     {
    120         psDB            *dbh;
    121         psFits          *fits;
    122 
    123         dbh = psDBInit("localhost", "test", NULL, "test");
    124         if (!dbh) {
    125             exit(EXIT_FAILURE);
    126         }
    127 
    128         fits = psFitsOpen(TMP_FILENAME, "w");
    129         if (!fits) {
    130             exit(EXIT_FAILURE);
    131         }
    132 
    133         if (!skyp_irSelectRowsFits(dbh, fits, NULL, 1)) {
    134             exit(EXIT_FAILURE);
    135         }
    136 
    137         psFree(fits);
    138         psDBCleanup(dbh);
    139     }
    140 
    141     {
    142         psDB            *dbh;
    143         psFits          *fits;
    144 
    145         dbh = psDBInit("localhost", "test", NULL, "test");
    146         if (!dbh) {
    147             exit(EXIT_FAILURE);
    148         }
    149 
    150         fits = psFitsOpen(TMP_FILENAME, "w");
    151         if (!fits) {
    152             exit(EXIT_FAILURE);
    153         }
    154 
    155         if (!domeSelectRowsFits(dbh, fits, NULL, 1)) {
    156             exit(EXIT_FAILURE);
    157         }
    158 
    159         psFree(fits);
    160         psDBCleanup(dbh);
    161     }
    162 
    163     {
    164         psDB            *dbh;
    165         psFits          *fits;
    166 
    167         dbh = psDBInit("localhost", "test", NULL, "test");
    168         if (!dbh) {
    169             exit(EXIT_FAILURE);
    170         }
    171 
    172         fits = psFitsOpen(TMP_FILENAME, "w");
    173         if (!fits) {
    174             exit(EXIT_FAILURE);
    175         }
    176 
    177         if (!telescopeSelectRowsFits(dbh, fits, NULL, 1)) {
    178             exit(EXIT_FAILURE);
    179         }
    180 
    181         psFree(fits);
    182         psDBCleanup(dbh);
    183     }
    184 
    185     {
    186         psDB            *dbh;
    187         psFits          *fits;
    188 
    189         dbh = psDBInit("localhost", "test", NULL, "test");
    190         if (!dbh) {
    191             exit(EXIT_FAILURE);
    192         }
    193 
    194         fits = psFitsOpen(TMP_FILENAME, "w");
    195         if (!fits) {
    196             exit(EXIT_FAILURE);
    197         }
    198 
    19923        if (!summitExpSelectRowsFits(dbh, fits, NULL, 1)) {
    20024            exit(EXIT_FAILURE);
Note: See TracChangeset for help on using the changeset viewer.