IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Oct 30, 2007, 4:45:31 PM (19 years ago)
Author:
jhoblitt
Message:

update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/tests/metadatafromobject.c

    r15420 r15421  
    1010    {
    1111        psMetadata      *md;
     12        pzDataStoreRow  *object;
     13        bool            status;
     14
     15        object = pzDataStoreRowAlloc("a string", "a string", "a string");
     16        if (!object) {
     17            exit(EXIT_FAILURE);
     18        }
     19
     20        md = pzDataStoreMetadataFromObject(object);
     21        if (!md) {
     22            exit(EXIT_FAILURE);
     23        }
     24
     25        psFree(object);
     26
     27        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     28            psFree(md);
     29            exit(EXIT_FAILURE);
     30        }
     31        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     32            psFree(md);
     33            exit(EXIT_FAILURE);
     34        }
     35        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     36            psFree(md);
     37            exit(EXIT_FAILURE);
     38        }
     39
     40        psFree(md);
     41    }
     42
     43    {
     44        psMetadata      *md;
    1245        summitExpRow    *object;
    1346        bool            status;
    … …  
    151184        bool            status;
    152185
    153         object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string", -64);
     186        object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string");
    154187        if (!object) {
    155188            exit(EXIT_FAILURE);
    … …  
    183216            exit(EXIT_FAILURE);
    184217        }
    185             psFree(md);
    186             exit(EXIT_FAILURE);
    187         }
    188218
    189219        psFree(md);
    … …  
    228258        bool            status;
    229259
    230         object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", -64, "a string");
     260        object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string");
    231261        if (!object) {
    232262            exit(EXIT_FAILURE);
    … …  
    260290            exit(EXIT_FAILURE);
    261291        }
    262             psFree(md);
    263             exit(EXIT_FAILURE);
    264         }
    265292        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    266293            psFree(md);
    … …  
    276303        bool            status;
    277304
    278         object = newExpRowAlloc(-64, "a string", "a string", "a string", "a string", -32, "a string", "a string");
     305        object = newExpRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "a string", "a string");
    279306        if (!object) {
    280307            exit(EXIT_FAILURE);
    … …  
    307334            exit(EXIT_FAILURE);
    308335        }
    309         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    310             psFree(md);
    311             exit(EXIT_FAILURE);
    312         }
    313336        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    314337            psFree(md);
    … …  
    319342            exit(EXIT_FAILURE);
    320343        }
     344        if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) {
     345            psFree(md);
     346            exit(EXIT_FAILURE);
     347        }
    321348
    322349        psFree(md);
    … …  
    360387        bool            status;
    361388
    362         object = rawExpRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32, "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", 32.32, -16);
     389        object = rawExpRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", 32.32, -16);
    363390        if (!object) {
    364391            exit(EXIT_FAILURE);
    … …  
    398425            exit(EXIT_FAILURE);
    399426        }
    400         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    401             psFree(md);
    402             exit(EXIT_FAILURE);
    403         }
    404427        if (strncmp(psMetadataLookupPtr(&status, md, "filelevel"), "a string", MAX_STRING_LENGTH)) {
    405428            psFree(md);
    … …  
    410433            exit(EXIT_FAILURE);
    411434        }
     435        if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) {
     436            psFree(md);
     437            exit(EXIT_FAILURE);
     438        }
    412439        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    413440            psFree(md);
    … …  
    671698        bool            status;
    672699
    673         object = chipRunRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "a string", "a string");
     700        object = chipRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string");
    674701        if (!object) {
    675702            exit(EXIT_FAILURE);
    … …  
    686713            exit(EXIT_FAILURE);
    687714        }
     715            psFree(md);
     716            exit(EXIT_FAILURE);
     717        }
    688718        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    689719            psFree(md);
    … …  
    720750    {
    721751        psMetadata      *md;
    722         chipInputImfileRow *object;
    723         bool            status;
    724 
    725         object = chipInputImfileRowAlloc(-64, -64, "a string");
    726         if (!object) {
    727             exit(EXIT_FAILURE);
    728         }
    729 
    730         md = chipInputImfileMetadataFromObject(object);
     752        chipProcessedImfileRow *object;
     753        bool            status;
     754
     755        object = chipProcessedImfileRowAlloc(-64, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
     756        if (!object) {
     757            exit(EXIT_FAILURE);
     758        }
     759
     760        md = chipProcessedImfileMetadataFromObject(object);
    731761        if (!md) {
    732762            exit(EXIT_FAILURE);
    … …  
    745775            exit(EXIT_FAILURE);
    746776        }
    747 
    748         psFree(md);
    749     }
    750 
    751     {
    752         psMetadata      *md;
    753         chipProcessedImfileRow *object;
    754         bool            status;
    755 
    756         object = chipProcessedImfileRowAlloc(-64, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
    757         if (!object) {
    758             exit(EXIT_FAILURE);
    759         }
    760 
    761         md = chipProcessedImfileMetadataFromObject(object);
    762         if (!md) {
    763             exit(EXIT_FAILURE);
    764         }
    765 
    766         psFree(object);
    767 
     777        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     778            psFree(md);
     779            exit(EXIT_FAILURE);
     780        }
     781        if (!psMetadataLookupF32(&status, md, "bg") == 32.32) {
     782            psFree(md);
     783            exit(EXIT_FAILURE);
     784        }
     785        if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) {
     786            psFree(md);
     787            exit(EXIT_FAILURE);
     788        }
     789        if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) {
     790            psFree(md);
     791            exit(EXIT_FAILURE);
     792        }
     793        if (!psMetadataLookupF32(&status, md, "bias") == 32.32) {
     794            psFree(md);
     795            exit(EXIT_FAILURE);
     796        }
     797        if (!psMetadataLookupF32(&status, md, "bias_stdev") == 32.32) {
     798            psFree(md);
     799            exit(EXIT_FAILURE);
     800        }
     801        if (!psMetadataLookupF32(&status, md, "fringe_0") == 32.32) {
     802            psFree(md);
     803            exit(EXIT_FAILURE);
     804        }
     805        if (!psMetadataLookupF32(&status, md, "fringe_1") == 32.32) {
     806            psFree(md);
     807            exit(EXIT_FAILURE);
     808        }
     809        if (!psMetadataLookupF32(&status, md, "fringe_2") == 32.32) {
     810            psFree(md);
     811            exit(EXIT_FAILURE);
     812        }
     813        if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) {
     814            psFree(md);
     815            exit(EXIT_FAILURE);
     816        }
     817        if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) {
     818            psFree(md);
     819            exit(EXIT_FAILURE);
     820        }
     821        if (!psMetadataLookupF32(&status, md, "ap_resid") == 32.32) {
     822            psFree(md);
     823            exit(EXIT_FAILURE);
     824        }
     825        if (!psMetadataLookupF32(&status, md, "ap_resid_stdev") == 32.32) {
     826            psFree(md);
     827            exit(EXIT_FAILURE);
     828        }
     829        if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
     830            psFree(md);
     831            exit(EXIT_FAILURE);
     832        }
     833        if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) {
     834            psFree(md);
     835            exit(EXIT_FAILURE);
     836        }
     837        if (!psMetadataLookupS32(&status, md, "n_stars") == -32) {
     838            psFree(md);
     839            exit(EXIT_FAILURE);
     840        }
     841        if (!psMetadataLookupS32(&status, md, "n_extended") == -32) {
     842            psFree(md);
     843            exit(EXIT_FAILURE);
     844        }
     845        if (!psMetadataLookupS32(&status, md, "n_cr") == -32) {
     846            psFree(md);
     847            exit(EXIT_FAILURE);
     848        }
     849        if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) {
     850            psFree(md);
     851            exit(EXIT_FAILURE);
     852        }
     853        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     854            psFree(md);
     855            exit(EXIT_FAILURE);
     856        }
     857            psFree(md);
     858            exit(EXIT_FAILURE);
     859        }
     860
     861        psFree(md);
     862    }
     863
     864    {
     865        psMetadata      *md;
     866        chipMaskRow     *object;
     867        bool            status;
     868
     869        object = chipMaskRowAlloc("a string");
     870        if (!object) {
     871            exit(EXIT_FAILURE);
     872        }
     873
     874        md = chipMaskMetadataFromObject(object);
     875        if (!md) {
     876            exit(EXIT_FAILURE);
     877        }
     878
     879        psFree(object);
     880
     881        if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) {
     882            psFree(md);
     883            exit(EXIT_FAILURE);
     884        }
     885
     886        psFree(md);
     887    }
     888
     889    {
     890        psMetadata      *md;
     891        camRunRow       *object;
     892        bool            status;
     893
     894        object = camRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string");
     895        if (!object) {
     896            exit(EXIT_FAILURE);
     897        }
     898
     899        md = camRunMetadataFromObject(object);
     900        if (!md) {
     901            exit(EXIT_FAILURE);
     902        }
     903
     904        psFree(object);
     905
     906            psFree(md);
     907            exit(EXIT_FAILURE);
     908        }
     909            psFree(md);
     910            exit(EXIT_FAILURE);
     911        }
     912        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     913            psFree(md);
     914            exit(EXIT_FAILURE);
     915        }
     916        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     917            psFree(md);
     918            exit(EXIT_FAILURE);
     919        }
     920        if (strncmp(psMetadataLookupPtr(&status, md, "workdir_state"), "a string", MAX_STRING_LENGTH)) {
     921            psFree(md);
     922            exit(EXIT_FAILURE);
     923        }
     924        if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) {
     925            psFree(md);
     926            exit(EXIT_FAILURE);
     927        }
     928        if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) {
     929            psFree(md);
     930            exit(EXIT_FAILURE);
     931        }
     932        if (strncmp(psMetadataLookupPtr(&status, md, "expgroup"), "a string", MAX_STRING_LENGTH)) {
     933            psFree(md);
     934            exit(EXIT_FAILURE);
     935        }
     936        if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
     937            psFree(md);
     938            exit(EXIT_FAILURE);
     939        }
     940
     941        psFree(md);
     942    }
     943
     944    {
     945        psMetadata      *md;
     946        camProcessedExpRow *object;
     947        bool            status;
     948
     949        object = camProcessedExpRowAlloc(-64, -64, "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
     950        if (!object) {
     951            exit(EXIT_FAILURE);
     952        }
     953
     954        md = camProcessedExpMetadataFromObject(object);
     955        if (!md) {
     956            exit(EXIT_FAILURE);
     957        }
     958
     959        psFree(object);
     960
     961            psFree(md);
     962            exit(EXIT_FAILURE);
     963        }
     964            psFree(md);
     965            exit(EXIT_FAILURE);
     966        }
     967        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     968            psFree(md);
     969            exit(EXIT_FAILURE);
     970        }
     971        if (!psMetadataLookupF32(&status, md, "bg") == 32.32) {
     972            psFree(md);
     973            exit(EXIT_FAILURE);
     974        }
     975        if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) {
     976            psFree(md);
     977            exit(EXIT_FAILURE);
     978        }
     979        if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) {
     980            psFree(md);
     981            exit(EXIT_FAILURE);
     982        }
     983        if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) {
     984            psFree(md);
     985            exit(EXIT_FAILURE);
     986        }
     987        if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) {
     988            psFree(md);
     989            exit(EXIT_FAILURE);
     990        }
     991        if (!psMetadataLookupF32(&status, md, "zp_mean") == 32.32) {
     992            psFree(md);
     993            exit(EXIT_FAILURE);
     994        }
     995        if (!psMetadataLookupF32(&status, md, "zp_stdev") == 32.32) {
     996            psFree(md);
     997            exit(EXIT_FAILURE);
     998        }
     999        if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
     1000            psFree(md);
     1001            exit(EXIT_FAILURE);
     1002        }
     1003        if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) {
     1004            psFree(md);
     1005            exit(EXIT_FAILURE);
     1006        }
     1007        if (!psMetadataLookupS32(&status, md, "n_stars") == -32) {
     1008            psFree(md);
     1009            exit(EXIT_FAILURE);
     1010        }
     1011        if (!psMetadataLookupS32(&status, md, "n_extended") == -32) {
     1012            psFree(md);
     1013            exit(EXIT_FAILURE);
     1014        }
     1015        if (!psMetadataLookupS32(&status, md, "n_cr") == -32) {
     1016            psFree(md);
     1017            exit(EXIT_FAILURE);
     1018        }
     1019        if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) {
     1020            psFree(md);
     1021            exit(EXIT_FAILURE);
     1022        }
     1023        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     1024            psFree(md);
     1025            exit(EXIT_FAILURE);
     1026        }
     1027            psFree(md);
     1028            exit(EXIT_FAILURE);
     1029        }
     1030
     1031        psFree(md);
     1032    }
     1033
     1034    {
     1035        psMetadata      *md;
     1036        camMaskRow      *object;
     1037        bool            status;
     1038
     1039        object = camMaskRowAlloc("a string");
     1040        if (!object) {
     1041            exit(EXIT_FAILURE);
     1042        }
     1043
     1044        md = camMaskMetadataFromObject(object);
     1045        if (!md) {
     1046            exit(EXIT_FAILURE);
     1047        }
     1048
     1049        psFree(object);
     1050
     1051        if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) {
     1052            psFree(md);
     1053            exit(EXIT_FAILURE);
     1054        }
     1055
     1056        psFree(md);
     1057    }
     1058
     1059    {
     1060        psMetadata      *md;
     1061        warpRunRow      *object;
     1062        bool            status;
     1063
     1064        object = warpRunRowAlloc(-64, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z");
     1065        if (!object) {
     1066            exit(EXIT_FAILURE);
     1067        }
     1068
     1069        md = warpRunMetadataFromObject(object);
     1070        if (!md) {
     1071            exit(EXIT_FAILURE);
     1072        }
     1073
     1074        psFree(object);
     1075
     1076            psFree(md);
     1077            exit(EXIT_FAILURE);
     1078        }
     1079        if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) {
     1080            psFree(md);
     1081            exit(EXIT_FAILURE);
     1082        }
     1083        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1084            psFree(md);
     1085            exit(EXIT_FAILURE);
     1086        }
     1087        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     1088            psFree(md);
     1089            exit(EXIT_FAILURE);
     1090        }
     1091        if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
     1092            psFree(md);
     1093            exit(EXIT_FAILURE);
     1094        }
     1095            psFree(md);
     1096            exit(EXIT_FAILURE);
     1097        }
     1098
     1099        psFree(md);
     1100    }
     1101
     1102    {
     1103        psMetadata      *md;
     1104        warpInputExpRow *object;
     1105        bool            status;
     1106
     1107        object = warpInputExpRowAlloc(-64, -64, true);
     1108        if (!object) {
     1109            exit(EXIT_FAILURE);
     1110        }
     1111
     1112        md = warpInputExpMetadataFromObject(object);
     1113        if (!md) {
     1114            exit(EXIT_FAILURE);
     1115        }
     1116
     1117        psFree(object);
     1118
     1119            psFree(md);
     1120            exit(EXIT_FAILURE);
     1121        }
     1122            psFree(md);
     1123            exit(EXIT_FAILURE);
     1124        }
     1125        if (!psMetadataLookupBool(&status, md, "magiced") == true) {
     1126            psFree(md);
     1127            exit(EXIT_FAILURE);
     1128        }
     1129
     1130        psFree(md);
     1131    }
     1132
     1133    {
     1134        psMetadata      *md;
     1135        warpSkyCellMapRow *object;
     1136        bool            status;
     1137
     1138        object = warpSkyCellMapRowAlloc(-64, "a string", "a string", -64, "a string", -16);
     1139        if (!object) {
     1140            exit(EXIT_FAILURE);
     1141        }
     1142
     1143        md = warpSkyCellMapMetadataFromObject(object);
     1144        if (!md) {
     1145            exit(EXIT_FAILURE);
     1146        }
     1147
     1148        psFree(object);
     1149
     1150            psFree(md);
     1151            exit(EXIT_FAILURE);
     1152        }
     1153        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1154            psFree(md);
     1155            exit(EXIT_FAILURE);
     1156        }
     1157        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
    7681158            psFree(md);
    7691159            exit(EXIT_FAILURE);
    … …  
    7761166            exit(EXIT_FAILURE);
    7771167        }
     1168            psFree(md);
     1169            exit(EXIT_FAILURE);
     1170        }
     1171
     1172        psFree(md);
     1173    }
     1174
     1175    {
     1176        psMetadata      *md;
     1177        warpSkyfileRow  *object;
     1178        bool            status;
     1179
     1180        object = warpSkyfileRowAlloc(-64, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, -16);
     1181        if (!object) {
     1182            exit(EXIT_FAILURE);
     1183        }
     1184
     1185        md = warpSkyfileMetadataFromObject(object);
     1186        if (!md) {
     1187            exit(EXIT_FAILURE);
     1188        }
     1189
     1190        psFree(object);
     1191
     1192            psFree(md);
     1193            exit(EXIT_FAILURE);
     1194        }
     1195        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1196            psFree(md);
     1197            exit(EXIT_FAILURE);
     1198        }
     1199        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1200            psFree(md);
     1201            exit(EXIT_FAILURE);
     1202        }
    7781203        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    7791204            psFree(md);
    7801205            exit(EXIT_FAILURE);
    7811206        }
    782         if (!psMetadataLookupF32(&status, md, "bg") == 32.32) {
    783             psFree(md);
    784             exit(EXIT_FAILURE);
    785         }
    786         if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) {
    787             psFree(md);
    788             exit(EXIT_FAILURE);
    789         }
    790         if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) {
    791             psFree(md);
    792             exit(EXIT_FAILURE);
    793         }
    794         if (!psMetadataLookupF32(&status, md, "bias") == 32.32) {
    795             psFree(md);
    796             exit(EXIT_FAILURE);
    797         }
    798         if (!psMetadataLookupF32(&status, md, "bias_stdev") == 32.32) {
    799             psFree(md);
    800             exit(EXIT_FAILURE);
    801         }
    802         if (!psMetadataLookupF32(&status, md, "fringe_0") == 32.32) {
    803             psFree(md);
    804             exit(EXIT_FAILURE);
    805         }
    806         if (!psMetadataLookupF32(&status, md, "fringe_1") == 32.32) {
    807             psFree(md);
    808             exit(EXIT_FAILURE);
    809         }
    810         if (!psMetadataLookupF32(&status, md, "fringe_2") == 32.32) {
    811             psFree(md);
    812             exit(EXIT_FAILURE);
    813         }
    814         if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) {
    815             psFree(md);
    816             exit(EXIT_FAILURE);
    817         }
    818         if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) {
    819             psFree(md);
    820             exit(EXIT_FAILURE);
    821         }
    822         if (!psMetadataLookupF32(&status, md, "ap_resid") == 32.32) {
    823             psFree(md);
    824             exit(EXIT_FAILURE);
    825         }
    826         if (!psMetadataLookupF32(&status, md, "ap_resid_stdev") == 32.32) {
    827             psFree(md);
    828             exit(EXIT_FAILURE);
    829         }
    830         if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
    831             psFree(md);
    832             exit(EXIT_FAILURE);
    833         }
    834         if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) {
    835             psFree(md);
    836             exit(EXIT_FAILURE);
    837         }
    838         if (!psMetadataLookupS32(&status, md, "n_stars") == -32) {
    839             psFree(md);
    840             exit(EXIT_FAILURE);
    841         }
    842         if (!psMetadataLookupS32(&status, md, "n_extended") == -32) {
    843             psFree(md);
    844             exit(EXIT_FAILURE);
    845         }
    846         if (!psMetadataLookupS32(&status, md, "n_cr") == -32) {
    847             psFree(md);
    848             exit(EXIT_FAILURE);
    849         }
    850         if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) {
    851             psFree(md);
    852             exit(EXIT_FAILURE);
    853         }
    8541207        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    8551208            psFree(md);
    8561209            exit(EXIT_FAILURE);
    8571210        }
    858             psFree(md);
    859             exit(EXIT_FAILURE);
    860         }
    861 
    862         psFree(md);
    863     }
    864 
    865     {
    866         psMetadata      *md;
    867         chipMaskRow     *object;
    868         bool            status;
    869 
    870         object = chipMaskRowAlloc("a string");
    871         if (!object) {
    872             exit(EXIT_FAILURE);
    873         }
    874 
    875         md = chipMaskMetadataFromObject(object);
    876         if (!md) {
    877             exit(EXIT_FAILURE);
    878         }
    879 
    880         psFree(object);
    881 
     1211        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1212            psFree(md);
     1213            exit(EXIT_FAILURE);
     1214        }
     1215        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1216            psFree(md);
     1217            exit(EXIT_FAILURE);
     1218        }
     1219        if (!psMetadataLookupF64(&status, md, "good_frac") == 64.64) {
     1220            psFree(md);
     1221            exit(EXIT_FAILURE);
     1222        }
     1223            psFree(md);
     1224            exit(EXIT_FAILURE);
     1225        }
     1226
     1227        psFree(md);
     1228    }
     1229
     1230    {
     1231        psMetadata      *md;
     1232        diffRunRow      *object;
     1233        bool            status;
     1234
     1235        object = diffRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string");
     1236        if (!object) {
     1237            exit(EXIT_FAILURE);
     1238        }
     1239
     1240        md = diffRunMetadataFromObject(object);
     1241        if (!md) {
     1242            exit(EXIT_FAILURE);
     1243        }
     1244
     1245        psFree(object);
     1246
     1247            psFree(md);
     1248            exit(EXIT_FAILURE);
     1249        }
     1250        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1251            psFree(md);
     1252            exit(EXIT_FAILURE);
     1253        }
     1254        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     1255            psFree(md);
     1256            exit(EXIT_FAILURE);
     1257        }
     1258        if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
     1259            psFree(md);
     1260            exit(EXIT_FAILURE);
     1261        }
     1262            psFree(md);
     1263            exit(EXIT_FAILURE);
     1264        }
     1265        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1266            psFree(md);
     1267            exit(EXIT_FAILURE);
     1268        }
     1269        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1270            psFree(md);
     1271            exit(EXIT_FAILURE);
     1272        }
     1273
     1274        psFree(md);
     1275    }
     1276
     1277    {
     1278        psMetadata      *md;
     1279        diffInputSkyfileRow *object;
     1280        bool            status;
     1281
     1282        object = diffInputSkyfileRowAlloc(-64, true, -64, -64, "a string", "a string", "a string");
     1283        if (!object) {
     1284            exit(EXIT_FAILURE);
     1285        }
     1286
     1287        md = diffInputSkyfileMetadataFromObject(object);
     1288        if (!md) {
     1289            exit(EXIT_FAILURE);
     1290        }
     1291
     1292        psFree(object);
     1293
     1294            psFree(md);
     1295            exit(EXIT_FAILURE);
     1296        }
     1297        if (!psMetadataLookupBool(&status, md, "template") == true) {
     1298            psFree(md);
     1299            exit(EXIT_FAILURE);
     1300        }
     1301            psFree(md);
     1302            exit(EXIT_FAILURE);
     1303        }
     1304            psFree(md);
     1305            exit(EXIT_FAILURE);
     1306        }
     1307        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1308            psFree(md);
     1309            exit(EXIT_FAILURE);
     1310        }
     1311        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1312            psFree(md);
     1313            exit(EXIT_FAILURE);
     1314        }
     1315        if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) {
     1316            psFree(md);
     1317            exit(EXIT_FAILURE);
     1318        }
     1319
     1320        psFree(md);
     1321    }
     1322
     1323    {
     1324        psMetadata      *md;
     1325        diffSkyfileRow  *object;
     1326        bool            status;
     1327
     1328        object = diffSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, 64.64, -16);
     1329        if (!object) {
     1330            exit(EXIT_FAILURE);
     1331        }
     1332
     1333        md = diffSkyfileMetadataFromObject(object);
     1334        if (!md) {
     1335            exit(EXIT_FAILURE);
     1336        }
     1337
     1338        psFree(object);
     1339
     1340            psFree(md);
     1341            exit(EXIT_FAILURE);
     1342        }
     1343        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1344            psFree(md);
     1345            exit(EXIT_FAILURE);
     1346        }
     1347        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     1348            psFree(md);
     1349            exit(EXIT_FAILURE);
     1350        }
     1351        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1352            psFree(md);
     1353            exit(EXIT_FAILURE);
     1354        }
     1355        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1356            psFree(md);
     1357            exit(EXIT_FAILURE);
     1358        }
     1359        if (!psMetadataLookupF64(&status, md, "good_frac") == 64.64) {
     1360            psFree(md);
     1361            exit(EXIT_FAILURE);
     1362        }
     1363            psFree(md);
     1364            exit(EXIT_FAILURE);
     1365        }
     1366
     1367        psFree(md);
     1368    }
     1369
     1370    {
     1371        psMetadata      *md;
     1372        stackRunRow     *object;
     1373        bool            status;
     1374
     1375        object = stackRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string");
     1376        if (!object) {
     1377            exit(EXIT_FAILURE);
     1378        }
     1379
     1380        md = stackRunMetadataFromObject(object);
     1381        if (!md) {
     1382            exit(EXIT_FAILURE);
     1383        }
     1384
     1385        psFree(object);
     1386
     1387            psFree(md);
     1388            exit(EXIT_FAILURE);
     1389        }
     1390        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1391            psFree(md);
     1392            exit(EXIT_FAILURE);
     1393        }
     1394        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     1395            psFree(md);
     1396            exit(EXIT_FAILURE);
     1397        }
     1398        if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
     1399            psFree(md);
     1400            exit(EXIT_FAILURE);
     1401        }
     1402            psFree(md);
     1403            exit(EXIT_FAILURE);
     1404        }
     1405        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1406            psFree(md);
     1407            exit(EXIT_FAILURE);
     1408        }
     1409        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1410            psFree(md);
     1411            exit(EXIT_FAILURE);
     1412        }
     1413
     1414        psFree(md);
     1415    }
     1416
     1417    {
     1418        psMetadata      *md;
     1419        stackInputSkyfileRow *object;
     1420        bool            status;
     1421
     1422        object = stackInputSkyfileRowAlloc(-64, -64);
     1423        if (!object) {
     1424            exit(EXIT_FAILURE);
     1425        }
     1426
     1427        md = stackInputSkyfileMetadataFromObject(object);
     1428        if (!md) {
     1429            exit(EXIT_FAILURE);
     1430        }
     1431
     1432        psFree(object);
     1433
     1434            psFree(md);
     1435            exit(EXIT_FAILURE);
     1436        }
     1437            psFree(md);
     1438            exit(EXIT_FAILURE);
     1439        }
     1440
     1441        psFree(md);
     1442    }
     1443
     1444    {
     1445        psMetadata      *md;
     1446        stackSumSkyfileRow *object;
     1447        bool            status;
     1448
     1449        object = stackSumSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, 64.64, -16);
     1450        if (!object) {
     1451            exit(EXIT_FAILURE);
     1452        }
     1453
     1454        md = stackSumSkyfileMetadataFromObject(object);
     1455        if (!md) {
     1456            exit(EXIT_FAILURE);
     1457        }
     1458
     1459        psFree(object);
     1460
     1461            psFree(md);
     1462            exit(EXIT_FAILURE);
     1463        }
     1464        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1465            psFree(md);
     1466            exit(EXIT_FAILURE);
     1467        }
     1468        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     1469            psFree(md);
     1470            exit(EXIT_FAILURE);
     1471        }
     1472        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1473            psFree(md);
     1474            exit(EXIT_FAILURE);
     1475        }
     1476        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1477            psFree(md);
     1478            exit(EXIT_FAILURE);
     1479        }
     1480        if (!psMetadataLookupF64(&status, md, "good_frac") == 64.64) {
     1481            psFree(md);
     1482            exit(EXIT_FAILURE);
     1483        }
     1484            psFree(md);
     1485            exit(EXIT_FAILURE);
     1486        }
     1487
     1488        psFree(md);
     1489    }
     1490
     1491    {
     1492        psMetadata      *md;
     1493        detRunRow       *object;
     1494        bool            status;
     1495
     1496        object = detRunRowAlloc(-64, -32, "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 64.64, 64.64, "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", 32.32, 32.32, "a string", -32);
     1497        if (!object) {
     1498            exit(EXIT_FAILURE);
     1499        }
     1500
     1501        md = detRunMetadataFromObject(object);
     1502        if (!md) {
     1503            exit(EXIT_FAILURE);
     1504        }
     1505
     1506        psFree(object);
     1507
     1508            psFree(md);
     1509            exit(EXIT_FAILURE);
     1510        }
     1511        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     1512            psFree(md);
     1513            exit(EXIT_FAILURE);
     1514        }
     1515        if (strncmp(psMetadataLookupPtr(&status, md, "det_type"), "a string", MAX_STRING_LENGTH)) {
     1516            psFree(md);
     1517            exit(EXIT_FAILURE);
     1518        }
     1519        if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) {
     1520            psFree(md);
     1521            exit(EXIT_FAILURE);
     1522        }
     1523        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1524            psFree(md);
     1525            exit(EXIT_FAILURE);
     1526        }
     1527        if (strncmp(psMetadataLookupPtr(&status, md, "filelevel"), "a string", MAX_STRING_LENGTH)) {
     1528            psFree(md);
     1529            exit(EXIT_FAILURE);
     1530        }
     1531        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     1532            psFree(md);
     1533            exit(EXIT_FAILURE);
     1534        }
     1535        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     1536            psFree(md);
     1537            exit(EXIT_FAILURE);
     1538        }
     1539        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     1540            psFree(md);
     1541            exit(EXIT_FAILURE);
     1542        }
     1543        if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
     1544            psFree(md);
     1545            exit(EXIT_FAILURE);
     1546        }
     1547        if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) {
     1548            psFree(md);
     1549            exit(EXIT_FAILURE);
     1550        }
     1551        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
     1552            psFree(md);
     1553            exit(EXIT_FAILURE);
     1554        }
     1555        if (!psMetadataLookupF32(&status, md, "airmass_min") == 32.32) {
     1556            psFree(md);
     1557            exit(EXIT_FAILURE);
     1558        }
     1559        if (!psMetadataLookupF32(&status, md, "airmass_max") == 32.32) {
     1560            psFree(md);
     1561            exit(EXIT_FAILURE);
     1562        }
     1563        if (!psMetadataLookupF32(&status, md, "exp_time_min") == 32.32) {
     1564            psFree(md);
     1565            exit(EXIT_FAILURE);
     1566        }
     1567        if (!psMetadataLookupF32(&status, md, "exp_time_max") == 32.32) {
     1568            psFree(md);
     1569            exit(EXIT_FAILURE);
     1570        }
     1571        if (!psMetadataLookupF32(&status, md, "ccd_temp_min") == 32.32) {
     1572            psFree(md);
     1573            exit(EXIT_FAILURE);
     1574        }
     1575        if (!psMetadataLookupF32(&status, md, "ccd_temp_max") == 32.32) {
     1576            psFree(md);
     1577            exit(EXIT_FAILURE);
     1578        }
     1579        if (!psMetadataLookupF64(&status, md, "posang_min") == 64.64) {
     1580            psFree(md);
     1581            exit(EXIT_FAILURE);
     1582        }
     1583        if (!psMetadataLookupF64(&status, md, "posang_max") == 64.64) {
     1584            psFree(md);
     1585            exit(EXIT_FAILURE);
     1586        }
     1587            psFree(md);
     1588            exit(EXIT_FAILURE);
     1589        }
     1590            psFree(md);
     1591            exit(EXIT_FAILURE);
     1592        }
     1593            psFree(md);
     1594            exit(EXIT_FAILURE);
     1595        }
     1596            psFree(md);
     1597            exit(EXIT_FAILURE);
     1598        }
     1599            psFree(md);
     1600            exit(EXIT_FAILURE);
     1601        }
     1602        if (!psMetadataLookupF32(&status, md, "solang_min") == 32.32) {
     1603            psFree(md);
     1604            exit(EXIT_FAILURE);
     1605        }
     1606        if (!psMetadataLookupF32(&status, md, "solang_max") == 32.32) {
     1607            psFree(md);
     1608            exit(EXIT_FAILURE);
     1609        }
    8821610        if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) {
    8831611            psFree(md);
    8841612            exit(EXIT_FAILURE);
    8851613        }
    886 
    887         psFree(md);
    888     }
    889 
    890     {
    891         psMetadata      *md;
    892         camRunRow       *object;
    893         bool            status;
    894 
    895         object = camRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string");
    896         if (!object) {
    897             exit(EXIT_FAILURE);
    898         }
    899 
    900         md = camRunMetadataFromObject(object);
    901         if (!md) {
    902             exit(EXIT_FAILURE);
    903         }
    904 
    905         psFree(object);
    906 
    907             psFree(md);
    908             exit(EXIT_FAILURE);
    909         }
     1614        if (!psMetadataLookupS32(&status, md, "parent") == -32) {
     1615            psFree(md);
     1616            exit(EXIT_FAILURE);
     1617        }
     1618
     1619        psFree(md);
     1620    }
     1621
     1622    {
     1623        psMetadata      *md;
     1624        detInputExpRow  *object;
     1625        bool            status;
     1626
     1627        object = detInputExpRowAlloc(-64, -32, -64, true);
     1628        if (!object) {
     1629            exit(EXIT_FAILURE);
     1630        }
     1631
     1632        md = detInputExpMetadataFromObject(object);
     1633        if (!md) {
     1634            exit(EXIT_FAILURE);
     1635        }
     1636
     1637        psFree(object);
     1638
     1639            psFree(md);
     1640            exit(EXIT_FAILURE);
     1641        }
     1642        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     1643            psFree(md);
     1644            exit(EXIT_FAILURE);
     1645        }
     1646            psFree(md);
     1647            exit(EXIT_FAILURE);
     1648        }
     1649        if (!psMetadataLookupBool(&status, md, "include") == true) {
     1650            psFree(md);
     1651            exit(EXIT_FAILURE);
     1652        }
     1653
     1654        psFree(md);
     1655    }
     1656
     1657    {
     1658        psMetadata      *md;
     1659        detProcessedImfileRow *object;
     1660        bool            status;
     1661
     1662        object = detProcessedImfileRowAlloc(-64, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
     1663        if (!object) {
     1664            exit(EXIT_FAILURE);
     1665        }
     1666
     1667        md = detProcessedImfileMetadataFromObject(object);
     1668        if (!md) {
     1669            exit(EXIT_FAILURE);
     1670        }
     1671
     1672        psFree(object);
     1673
     1674            psFree(md);
     1675            exit(EXIT_FAILURE);
     1676        }
     1677            psFree(md);
     1678            exit(EXIT_FAILURE);
     1679        }
     1680        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1681            psFree(md);
     1682            exit(EXIT_FAILURE);
     1683        }
     1684        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1685            psFree(md);
     1686            exit(EXIT_FAILURE);
     1687        }
     1688        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     1689            psFree(md);
     1690            exit(EXIT_FAILURE);
     1691        }
     1692        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1693            psFree(md);
     1694            exit(EXIT_FAILURE);
     1695        }
     1696        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1697            psFree(md);
     1698            exit(EXIT_FAILURE);
     1699        }
     1700        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1701            psFree(md);
     1702            exit(EXIT_FAILURE);
     1703        }
     1704        if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
     1705            psFree(md);
     1706            exit(EXIT_FAILURE);
     1707        }
     1708        if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
     1709            psFree(md);
     1710            exit(EXIT_FAILURE);
     1711        }
     1712        if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
     1713            psFree(md);
     1714            exit(EXIT_FAILURE);
     1715        }
     1716        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     1717            psFree(md);
     1718            exit(EXIT_FAILURE);
     1719        }
     1720        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     1721            psFree(md);
     1722            exit(EXIT_FAILURE);
     1723        }
     1724        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     1725            psFree(md);
     1726            exit(EXIT_FAILURE);
     1727        }
     1728        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     1729            psFree(md);
     1730            exit(EXIT_FAILURE);
     1731        }
     1732        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     1733            psFree(md);
     1734            exit(EXIT_FAILURE);
     1735        }
     1736        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     1737            psFree(md);
     1738            exit(EXIT_FAILURE);
     1739        }
     1740            psFree(md);
     1741            exit(EXIT_FAILURE);
     1742        }
     1743
     1744        psFree(md);
     1745    }
     1746
     1747    {
     1748        psMetadata      *md;
     1749        detProcessedExpRow *object;
     1750        bool            status;
     1751
     1752        object = detProcessedExpRowAlloc(-64, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
     1753        if (!object) {
     1754            exit(EXIT_FAILURE);
     1755        }
     1756
     1757        md = detProcessedExpMetadataFromObject(object);
     1758        if (!md) {
     1759            exit(EXIT_FAILURE);
     1760        }
     1761
     1762        psFree(object);
     1763
     1764            psFree(md);
     1765            exit(EXIT_FAILURE);
     1766        }
     1767            psFree(md);
     1768            exit(EXIT_FAILURE);
     1769        }
     1770        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     1771            psFree(md);
     1772            exit(EXIT_FAILURE);
     1773        }
     1774        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1775            psFree(md);
     1776            exit(EXIT_FAILURE);
     1777        }
     1778        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1779            psFree(md);
     1780            exit(EXIT_FAILURE);
     1781        }
     1782        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1783            psFree(md);
     1784            exit(EXIT_FAILURE);
     1785        }
     1786        if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
     1787            psFree(md);
     1788            exit(EXIT_FAILURE);
     1789        }
     1790        if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
     1791            psFree(md);
     1792            exit(EXIT_FAILURE);
     1793        }
     1794        if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
     1795            psFree(md);
     1796            exit(EXIT_FAILURE);
     1797        }
     1798        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     1799            psFree(md);
     1800            exit(EXIT_FAILURE);
     1801        }
     1802        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     1803            psFree(md);
     1804            exit(EXIT_FAILURE);
     1805        }
     1806        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     1807            psFree(md);
     1808            exit(EXIT_FAILURE);
     1809        }
     1810        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     1811            psFree(md);
     1812            exit(EXIT_FAILURE);
     1813        }
     1814        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     1815            psFree(md);
     1816            exit(EXIT_FAILURE);
     1817        }
     1818        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     1819            psFree(md);
     1820            exit(EXIT_FAILURE);
     1821        }
     1822            psFree(md);
     1823            exit(EXIT_FAILURE);
     1824        }
     1825
     1826        psFree(md);
     1827    }
     1828
     1829    {
     1830        psMetadata      *md;
     1831        detStackedImfileRow *object;
     1832        bool            status;
     1833
     1834        object = detStackedImfileRowAlloc(-64, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, -16);
     1835        if (!object) {
     1836            exit(EXIT_FAILURE);
     1837        }
     1838
     1839        md = detStackedImfileMetadataFromObject(object);
     1840        if (!md) {
     1841            exit(EXIT_FAILURE);
     1842        }
     1843
     1844        psFree(object);
     1845
     1846            psFree(md);
     1847            exit(EXIT_FAILURE);
     1848        }
     1849        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     1850            psFree(md);
     1851            exit(EXIT_FAILURE);
     1852        }
     1853        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1854            psFree(md);
     1855            exit(EXIT_FAILURE);
     1856        }
     1857        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1858            psFree(md);
     1859            exit(EXIT_FAILURE);
     1860        }
     1861        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     1862            psFree(md);
     1863            exit(EXIT_FAILURE);
     1864        }
     1865        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1866            psFree(md);
     1867            exit(EXIT_FAILURE);
     1868        }
     1869        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1870            psFree(md);
     1871            exit(EXIT_FAILURE);
     1872        }
     1873        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1874            psFree(md);
     1875            exit(EXIT_FAILURE);
     1876        }
     1877        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     1878            psFree(md);
     1879            exit(EXIT_FAILURE);
     1880        }
     1881        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     1882            psFree(md);
     1883            exit(EXIT_FAILURE);
     1884        }
     1885        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     1886            psFree(md);
     1887            exit(EXIT_FAILURE);
     1888        }
     1889        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     1890            psFree(md);
     1891            exit(EXIT_FAILURE);
     1892        }
     1893        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     1894            psFree(md);
     1895            exit(EXIT_FAILURE);
     1896        }
     1897            psFree(md);
     1898            exit(EXIT_FAILURE);
     1899        }
     1900
     1901        psFree(md);
     1902    }
     1903
     1904    {
     1905        psMetadata      *md;
     1906        detNormalizedStatImfileRow *object;
     1907        bool            status;
     1908
     1909        object = detNormalizedStatImfileRowAlloc(-64, -32, "a string", 32.32, -16);
     1910        if (!object) {
     1911            exit(EXIT_FAILURE);
     1912        }
     1913
     1914        md = detNormalizedStatImfileMetadataFromObject(object);
     1915        if (!md) {
     1916            exit(EXIT_FAILURE);
     1917        }
     1918
     1919        psFree(object);
     1920
     1921            psFree(md);
     1922            exit(EXIT_FAILURE);
     1923        }
     1924        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     1925            psFree(md);
     1926            exit(EXIT_FAILURE);
     1927        }
     1928        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1929            psFree(md);
     1930            exit(EXIT_FAILURE);
     1931        }
     1932        if (!psMetadataLookupF32(&status, md, "norm") == 32.32) {
     1933            psFree(md);
     1934            exit(EXIT_FAILURE);
     1935        }
     1936            psFree(md);
     1937            exit(EXIT_FAILURE);
     1938        }
     1939
     1940        psFree(md);
     1941    }
     1942
     1943    {
     1944        psMetadata      *md;
     1945        detNormalizedImfileRow *object;
     1946        bool            status;
     1947
     1948        object = detNormalizedImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
     1949        if (!object) {
     1950            exit(EXIT_FAILURE);
     1951        }
     1952
     1953        md = detNormalizedImfileMetadataFromObject(object);
     1954        if (!md) {
     1955            exit(EXIT_FAILURE);
     1956        }
     1957
     1958        psFree(object);
     1959
     1960            psFree(md);
     1961            exit(EXIT_FAILURE);
     1962        }
     1963        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     1964            psFree(md);
     1965            exit(EXIT_FAILURE);
     1966        }
     1967        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1968            psFree(md);
     1969            exit(EXIT_FAILURE);
     1970        }
     1971        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1972            psFree(md);
     1973            exit(EXIT_FAILURE);
     1974        }
     1975        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1976            psFree(md);
     1977            exit(EXIT_FAILURE);
     1978        }
     1979        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     1980            psFree(md);
     1981            exit(EXIT_FAILURE);
     1982        }
     1983        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1984            psFree(md);
     1985            exit(EXIT_FAILURE);
     1986        }
     1987        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     1988            psFree(md);
     1989            exit(EXIT_FAILURE);
     1990        }
     1991        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     1992            psFree(md);
     1993            exit(EXIT_FAILURE);
     1994        }
     1995        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     1996            psFree(md);
     1997            exit(EXIT_FAILURE);
     1998        }
     1999        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     2000            psFree(md);
     2001            exit(EXIT_FAILURE);
     2002        }
     2003        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     2004            psFree(md);
     2005            exit(EXIT_FAILURE);
     2006        }
     2007        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2008            psFree(md);
     2009            exit(EXIT_FAILURE);
     2010        }
     2011            psFree(md);
     2012            exit(EXIT_FAILURE);
     2013        }
     2014
     2015        psFree(md);
     2016    }
     2017
     2018    {
     2019        psMetadata      *md;
     2020        detNormalizedExpRow *object;
     2021        bool            status;
     2022
     2023        object = detNormalizedExpRowAlloc(-64, -32, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
     2024        if (!object) {
     2025            exit(EXIT_FAILURE);
     2026        }
     2027
     2028        md = detNormalizedExpMetadataFromObject(object);
     2029        if (!md) {
     2030            exit(EXIT_FAILURE);
     2031        }
     2032
     2033        psFree(object);
     2034
     2035            psFree(md);
     2036            exit(EXIT_FAILURE);
     2037        }
     2038        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     2039            psFree(md);
     2040            exit(EXIT_FAILURE);
     2041        }
     2042        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     2043            psFree(md);
     2044            exit(EXIT_FAILURE);
     2045        }
     2046        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     2047            psFree(md);
     2048            exit(EXIT_FAILURE);
     2049        }
     2050        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     2051            psFree(md);
     2052            exit(EXIT_FAILURE);
     2053        }
     2054        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     2055            psFree(md);
     2056            exit(EXIT_FAILURE);
     2057        }
     2058        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     2059            psFree(md);
     2060            exit(EXIT_FAILURE);
     2061        }
     2062        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     2063            psFree(md);
     2064            exit(EXIT_FAILURE);
     2065        }
     2066        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     2067            psFree(md);
     2068            exit(EXIT_FAILURE);
     2069        }
     2070        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     2071            psFree(md);
     2072            exit(EXIT_FAILURE);
     2073        }
     2074        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     2075            psFree(md);
     2076            exit(EXIT_FAILURE);
     2077        }
     2078        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2079            psFree(md);
     2080            exit(EXIT_FAILURE);
     2081        }
     2082            psFree(md);
     2083            exit(EXIT_FAILURE);
     2084        }
     2085
     2086        psFree(md);
     2087    }
     2088
     2089    {
     2090        psMetadata      *md;
     2091        detResidImfileRow *object;
     2092        bool            status;
     2093
     2094        object = detResidImfileRowAlloc(-64, -32, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
     2095        if (!object) {
     2096            exit(EXIT_FAILURE);
     2097        }
     2098
     2099        md = detResidImfileMetadataFromObject(object);
     2100        if (!md) {
     2101            exit(EXIT_FAILURE);
     2102        }
     2103
     2104        psFree(object);
     2105
     2106            psFree(md);
     2107            exit(EXIT_FAILURE);
     2108        }
     2109        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     2110            psFree(md);
     2111            exit(EXIT_FAILURE);
     2112        }
     2113            psFree(md);
     2114            exit(EXIT_FAILURE);
     2115        }
     2116        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     2117            psFree(md);
     2118            exit(EXIT_FAILURE);
     2119        }
     2120        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     2121            psFree(md);
     2122            exit(EXIT_FAILURE);
     2123        }
     2124        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     2125            psFree(md);
     2126            exit(EXIT_FAILURE);
     2127        }
     2128        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     2129            psFree(md);
     2130            exit(EXIT_FAILURE);
     2131        }
     2132        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     2133            psFree(md);
     2134            exit(EXIT_FAILURE);
     2135        }
     2136        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     2137            psFree(md);
     2138            exit(EXIT_FAILURE);
     2139        }
     2140        if (!psMetadataLookupF64(&status, md, "bg_skewness") == 64.64) {
     2141            psFree(md);
     2142            exit(EXIT_FAILURE);
     2143        }
     2144        if (!psMetadataLookupF64(&status, md, "bg_kurtosis") == 64.64) {
     2145            psFree(md);
     2146            exit(EXIT_FAILURE);
     2147        }
     2148        if (!psMetadataLookupF64(&status, md, "bin_stdev") == 64.64) {
     2149            psFree(md);
     2150            exit(EXIT_FAILURE);
     2151        }
     2152        if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
     2153            psFree(md);
     2154            exit(EXIT_FAILURE);
     2155        }
     2156        if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
     2157            psFree(md);
     2158            exit(EXIT_FAILURE);
     2159        }
     2160        if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
     2161            psFree(md);
     2162            exit(EXIT_FAILURE);
     2163        }
     2164        if (!psMetadataLookupF64(&status, md, "fringe_resid_0") == 64.64) {
     2165            psFree(md);
     2166            exit(EXIT_FAILURE);
     2167        }
     2168        if (!psMetadataLookupF64(&status, md, "fringe_resid_1") == 64.64) {
     2169            psFree(md);
     2170            exit(EXIT_FAILURE);
     2171        }
     2172        if (!psMetadataLookupF64(&status, md, "fringe_resid_2") == 64.64) {
     2173            psFree(md);
     2174            exit(EXIT_FAILURE);
     2175        }
     2176        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     2177            psFree(md);
     2178            exit(EXIT_FAILURE);
     2179        }
     2180        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     2181            psFree(md);
     2182            exit(EXIT_FAILURE);
     2183        }
     2184        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     2185            psFree(md);
     2186            exit(EXIT_FAILURE);
     2187        }
     2188        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     2189            psFree(md);
     2190            exit(EXIT_FAILURE);
     2191        }
     2192        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     2193            psFree(md);
     2194            exit(EXIT_FAILURE);
     2195        }
     2196        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2197            psFree(md);
     2198            exit(EXIT_FAILURE);
     2199        }
     2200            psFree(md);
     2201            exit(EXIT_FAILURE);
     2202        }
     2203
     2204        psFree(md);
     2205    }
     2206
     2207    {
     2208        psMetadata      *md;
     2209        detResidExpRow  *object;
     2210        bool            status;
     2211
     2212        object = detResidExpRowAlloc(-64, -32, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", true, -16);
     2213        if (!object) {
     2214            exit(EXIT_FAILURE);
     2215        }
     2216
     2217        md = detResidExpMetadataFromObject(object);
     2218        if (!md) {
     2219            exit(EXIT_FAILURE);
     2220        }
     2221
     2222        psFree(object);
     2223
     2224            psFree(md);
     2225            exit(EXIT_FAILURE);
     2226        }
     2227        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     2228            psFree(md);
     2229            exit(EXIT_FAILURE);
     2230        }
     2231            psFree(md);
     2232            exit(EXIT_FAILURE);
     2233        }
     2234        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     2235            psFree(md);
     2236            exit(EXIT_FAILURE);
     2237        }
     2238        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     2239            psFree(md);
     2240            exit(EXIT_FAILURE);
     2241        }
     2242        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     2243            psFree(md);
     2244            exit(EXIT_FAILURE);
     2245        }
     2246        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     2247            psFree(md);
     2248            exit(EXIT_FAILURE);
     2249        }
     2250        if (!psMetadataLookupF64(&status, md, "bg_skewness") == 64.64) {
     2251            psFree(md);
     2252            exit(EXIT_FAILURE);
     2253        }
     2254        if (!psMetadataLookupF64(&status, md, "bg_kurtosis") == 64.64) {
     2255            psFree(md);
     2256            exit(EXIT_FAILURE);
     2257        }
     2258        if (!psMetadataLookupF64(&status, md, "bin_stdev") == 64.64) {
     2259            psFree(md);
     2260            exit(EXIT_FAILURE);
     2261        }
     2262        if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
     2263            psFree(md);
     2264            exit(EXIT_FAILURE);
     2265        }
     2266        if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
     2267            psFree(md);
     2268            exit(EXIT_FAILURE);
     2269        }
     2270        if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
     2271            psFree(md);
     2272            exit(EXIT_FAILURE);
     2273        }
     2274        if (!psMetadataLookupF64(&status, md, "fringe_resid_0") == 64.64) {
     2275            psFree(md);
     2276            exit(EXIT_FAILURE);
     2277        }
     2278        if (!psMetadataLookupF64(&status, md, "fringe_resid_1") == 64.64) {
     2279            psFree(md);
     2280            exit(EXIT_FAILURE);
     2281        }
     2282        if (!psMetadataLookupF64(&status, md, "fringe_resid_2") == 64.64) {
     2283            psFree(md);
     2284            exit(EXIT_FAILURE);
     2285        }
     2286        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     2287            psFree(md);
     2288            exit(EXIT_FAILURE);
     2289        }
     2290        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     2291            psFree(md);
     2292            exit(EXIT_FAILURE);
     2293        }
     2294        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     2295            psFree(md);
     2296            exit(EXIT_FAILURE);
     2297        }
     2298        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     2299            psFree(md);
     2300            exit(EXIT_FAILURE);
     2301        }
     2302        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     2303            psFree(md);
     2304            exit(EXIT_FAILURE);
     2305        }
     2306        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2307            psFree(md);
     2308            exit(EXIT_FAILURE);
     2309        }
     2310        if (!psMetadataLookupBool(&status, md, "accept") == true) {
     2311            psFree(md);
     2312            exit(EXIT_FAILURE);
     2313        }
     2314            psFree(md);
     2315            exit(EXIT_FAILURE);
     2316        }
     2317
     2318        psFree(md);
     2319    }
     2320
     2321    {
     2322        psMetadata      *md;
     2323        detRunSummaryRow *object;
     2324        bool            status;
     2325
     2326        object = detRunSummaryRowAlloc(-64, -32, 64.64, 64.64, 64.64, true, -16);
     2327        if (!object) {
     2328            exit(EXIT_FAILURE);
     2329        }
     2330
     2331        md = detRunSummaryMetadataFromObject(object);
     2332        if (!md) {
     2333            exit(EXIT_FAILURE);
     2334        }
     2335
     2336        psFree(object);
     2337
     2338            psFree(md);
     2339            exit(EXIT_FAILURE);
     2340        }
     2341        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     2342            psFree(md);
     2343            exit(EXIT_FAILURE);
     2344        }
     2345        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     2346            psFree(md);
     2347            exit(EXIT_FAILURE);
     2348        }
     2349        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     2350            psFree(md);
     2351            exit(EXIT_FAILURE);
     2352        }
     2353        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     2354            psFree(md);
     2355            exit(EXIT_FAILURE);
     2356        }
     2357        if (!psMetadataLookupBool(&status, md, "accept") == true) {
     2358            psFree(md);
     2359            exit(EXIT_FAILURE);
     2360        }
     2361            psFree(md);
     2362            exit(EXIT_FAILURE);
     2363        }
     2364
     2365        psFree(md);
     2366    }
     2367
     2368    {
     2369        psMetadata      *md;
     2370        detRegisteredImfileRow *object;
     2371        bool            status;
     2372
     2373        object = detRegisteredImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
     2374        if (!object) {
     2375            exit(EXIT_FAILURE);
     2376        }
     2377
     2378        md = detRegisteredImfileMetadataFromObject(object);
     2379        if (!md) {
     2380            exit(EXIT_FAILURE);
     2381        }
     2382
     2383        psFree(object);
     2384
     2385            psFree(md);
     2386            exit(EXIT_FAILURE);
     2387        }
     2388        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
     2389            psFree(md);
     2390            exit(EXIT_FAILURE);
     2391        }
     2392        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     2393            psFree(md);
     2394            exit(EXIT_FAILURE);
     2395        }
     2396        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     2397            psFree(md);
     2398            exit(EXIT_FAILURE);
     2399        }
     2400        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     2401            psFree(md);
     2402            exit(EXIT_FAILURE);
     2403        }
     2404        if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
     2405            psFree(md);
     2406            exit(EXIT_FAILURE);
     2407        }
     2408        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     2409            psFree(md);
     2410            exit(EXIT_FAILURE);
     2411        }
     2412        if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
     2413            psFree(md);
     2414            exit(EXIT_FAILURE);
     2415        }
     2416        if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
     2417            psFree(md);
     2418            exit(EXIT_FAILURE);
     2419        }
     2420        if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
     2421            psFree(md);
     2422            exit(EXIT_FAILURE);
     2423        }
     2424        if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
     2425            psFree(md);
     2426            exit(EXIT_FAILURE);
     2427        }
     2428        if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
     2429            psFree(md);
     2430            exit(EXIT_FAILURE);
     2431        }
     2432        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2433            psFree(md);
     2434            exit(EXIT_FAILURE);
     2435        }
     2436            psFree(md);
     2437            exit(EXIT_FAILURE);
     2438        }
     2439
     2440        psFree(md);
     2441    }
     2442
     2443    {
     2444        psMetadata      *md;
     2445        detCorrectedExpRow *object;
     2446        bool            status;
     2447
     2448        object = detCorrectedExpRowAlloc(-64, -64, "a string", -64, "a string", "a string", "a string", -16);
     2449        if (!object) {
     2450            exit(EXIT_FAILURE);
     2451        }
     2452
     2453        md = detCorrectedExpMetadataFromObject(object);
     2454        if (!md) {
     2455            exit(EXIT_FAILURE);
     2456        }
     2457
     2458        psFree(object);
     2459
     2460            psFree(md);
     2461            exit(EXIT_FAILURE);
     2462        }
     2463            psFree(md);
     2464            exit(EXIT_FAILURE);
     2465        }
     2466        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     2467            psFree(md);
     2468            exit(EXIT_FAILURE);
     2469        }
     2470            psFree(md);
     2471            exit(EXIT_FAILURE);
     2472        }
     2473        if (strncmp(psMetadataLookupPtr(&status, md, "corr_type"), "a string", MAX_STRING_LENGTH)) {
     2474            psFree(md);
     2475            exit(EXIT_FAILURE);
     2476        }
     2477        if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
     2478            psFree(md);
     2479            exit(EXIT_FAILURE);
     2480        }
     2481        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2482            psFree(md);
     2483            exit(EXIT_FAILURE);
     2484        }
     2485            psFree(md);
     2486            exit(EXIT_FAILURE);
     2487        }
     2488
     2489        psFree(md);
     2490    }
     2491
     2492    {
     2493        psMetadata      *md;
     2494        detCorrectedImfileRow *object;
     2495        bool            status;
     2496
     2497        object = detCorrectedImfileRowAlloc(-64, -64, "a string", "a string", "a string", -16);
     2498        if (!object) {
     2499            exit(EXIT_FAILURE);
     2500        }
     2501
     2502        md = detCorrectedImfileMetadataFromObject(object);
     2503        if (!md) {
     2504            exit(EXIT_FAILURE);
     2505        }
     2506
     2507        psFree(object);
     2508
     2509            psFree(md);
     2510            exit(EXIT_FAILURE);
     2511        }
     2512            psFree(md);
     2513            exit(EXIT_FAILURE);
     2514        }
     2515        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     2516            psFree(md);
     2517            exit(EXIT_FAILURE);
     2518        }
     2519        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     2520            psFree(md);
     2521            exit(EXIT_FAILURE);
     2522        }
     2523        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
     2524            psFree(md);
     2525            exit(EXIT_FAILURE);
     2526        }
     2527            psFree(md);
     2528            exit(EXIT_FAILURE);
     2529        }
     2530
     2531        psFree(md);
     2532    }
     2533
     2534    {
     2535        psMetadata      *md;
     2536        magicRunRow     *object;
     2537        bool            status;
     2538
     2539        object = magicRunRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z");
     2540        if (!object) {
     2541            exit(EXIT_FAILURE);
     2542        }
     2543
     2544        md = magicRunMetadataFromObject(object);
     2545        if (!md) {
     2546            exit(EXIT_FAILURE);
     2547        }
     2548
     2549        psFree(object);
     2550
    9102551            psFree(md);
    9112552            exit(EXIT_FAILURE);
    … …  
    9272568            exit(EXIT_FAILURE);
    9282569        }
    929         if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) {
    930             psFree(md);
    931             exit(EXIT_FAILURE);
    932         }
    933         if (strncmp(psMetadataLookupPtr(&status, md, "expgroup"), "a string", MAX_STRING_LENGTH)) {
    934             psFree(md);
    935             exit(EXIT_FAILURE);
    936         }
    9372570        if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
    9382571            psFree(md);
    9392572            exit(EXIT_FAILURE);
    9402573        }
    941 
    942         psFree(md);
    943     }
    944 
    945     {
    946         psMetadata      *md;
    947         camProcessedExpRow *object;
    948         bool            status;
    949 
    950         object = camProcessedExpRowAlloc(-64, -64, "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
    951         if (!object) {
    952             exit(EXIT_FAILURE);
    953         }
    954 
    955         md = camProcessedExpMetadataFromObject(object);
    956         if (!md) {
    957             exit(EXIT_FAILURE);
    958         }
    959 
    960         psFree(object);
    961 
    962             psFree(md);
    963             exit(EXIT_FAILURE);
    964         }
     2574            psFree(md);
     2575            exit(EXIT_FAILURE);
     2576        }
     2577
     2578        psFree(md);
     2579    }
     2580
     2581    {
     2582        psMetadata      *md;
     2583        magicInputSkyfileRow *object;
     2584        bool            status;
     2585
     2586        object = magicInputSkyfileRowAlloc(-64, -64, "a string");
     2587        if (!object) {
     2588            exit(EXIT_FAILURE);
     2589        }
     2590
     2591        md = magicInputSkyfileMetadataFromObject(object);
     2592        if (!md) {
     2593            exit(EXIT_FAILURE);
     2594        }
     2595
     2596        psFree(object);
     2597
     2598            psFree(md);
     2599            exit(EXIT_FAILURE);
     2600        }
     2601            psFree(md);
     2602            exit(EXIT_FAILURE);
     2603        }
     2604        if (strncmp(psMetadataLookupPtr(&status, md, "node"), "a string", MAX_STRING_LENGTH)) {
     2605            psFree(md);
     2606            exit(EXIT_FAILURE);
     2607        }
     2608
     2609        psFree(md);
     2610    }
     2611
     2612    {
     2613        psMetadata      *md;
     2614        magicTreeRow    *object;
     2615        bool            status;
     2616
     2617        object = magicTreeRowAlloc(-64, "a string", "a string");
     2618        if (!object) {
     2619            exit(EXIT_FAILURE);
     2620        }
     2621
     2622        md = magicTreeMetadataFromObject(object);
     2623        if (!md) {
     2624            exit(EXIT_FAILURE);
     2625        }
     2626
     2627        psFree(object);
     2628
     2629            psFree(md);
     2630            exit(EXIT_FAILURE);
     2631        }
     2632        if (strncmp(psMetadataLookupPtr(&status, md, "node"), "a string", MAX_STRING_LENGTH)) {
     2633            psFree(md);
     2634            exit(EXIT_FAILURE);
     2635        }
     2636        if (strncmp(psMetadataLookupPtr(&status, md, "dep"), "a string", MAX_STRING_LENGTH)) {
     2637            psFree(md);
     2638            exit(EXIT_FAILURE);
     2639        }
     2640
     2641        psFree(md);
     2642    }
     2643
     2644    {
     2645        psMetadata      *md;
     2646        magicNodeResultRow *object;
     2647        bool            status;
     2648
     2649        object = magicNodeResultRowAlloc(-64, "a string", "a string");
     2650        if (!object) {
     2651            exit(EXIT_FAILURE);
     2652        }
     2653
     2654        md = magicNodeResultMetadataFromObject(object);
     2655        if (!md) {
     2656            exit(EXIT_FAILURE);
     2657        }
     2658
     2659        psFree(object);
     2660
     2661            psFree(md);
     2662            exit(EXIT_FAILURE);
     2663        }
     2664        if (strncmp(psMetadataLookupPtr(&status, md, "node"), "a string", MAX_STRING_LENGTH)) {
    9652665            psFree(md);
    9662666            exit(EXIT_FAILURE);
    … …  
    9702670            exit(EXIT_FAILURE);
    9712671        }
    972         if (!psMetadataLookupF32(&status, md, "bg") == 32.32) {
    973             psFree(md);
    974             exit(EXIT_FAILURE);
    975         }
    976         if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) {
    977             psFree(md);
    978             exit(EXIT_FAILURE);
    979         }
    980         if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) {
    981             psFree(md);
    982             exit(EXIT_FAILURE);
    983         }
    984         if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) {
    985             psFree(md);
    986             exit(EXIT_FAILURE);
    987         }
    988         if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) {
    989             psFree(md);
    990             exit(EXIT_FAILURE);
    991         }
    992         if (!psMetadataLookupF32(&status, md, "zp_mean") == 32.32) {
    993             psFree(md);
    994             exit(EXIT_FAILURE);
    995         }
    996         if (!psMetadataLookupF32(&status, md, "zp_stdev") == 32.32) {
    997             psFree(md);
    998             exit(EXIT_FAILURE);
    999         }
    1000         if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
    1001             psFree(md);
    1002             exit(EXIT_FAILURE);
    1003         }
    1004         if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) {
    1005             psFree(md);
    1006             exit(EXIT_FAILURE);
    1007         }
    1008         if (!psMetadataLookupS32(&status, md, "n_stars") == -32) {
    1009             psFree(md);
    1010             exit(EXIT_FAILURE);
    1011         }
    1012         if (!psMetadataLookupS32(&status, md, "n_extended") == -32) {
    1013             psFree(md);
    1014             exit(EXIT_FAILURE);
    1015         }
    1016         if (!psMetadataLookupS32(&status, md, "n_cr") == -32) {
    1017             psFree(md);
    1018             exit(EXIT_FAILURE);
    1019         }
    1020         if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) {
    1021             psFree(md);
    1022             exit(EXIT_FAILURE);
    1023         }
    1024         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1025             psFree(md);
    1026             exit(EXIT_FAILURE);
    1027         }
    1028             psFree(md);
    1029             exit(EXIT_FAILURE);
    1030         }
    1031 
    1032         psFree(md);
    1033     }
    1034 
    1035     {
    1036         psMetadata      *md;
    1037         camMaskRow      *object;
    1038         bool            status;
    1039 
    1040         object = camMaskRowAlloc("a string");
    1041         if (!object) {
    1042             exit(EXIT_FAILURE);
    1043         }
    1044 
    1045         md = camMaskMetadataFromObject(object);
    1046         if (!md) {
    1047             exit(EXIT_FAILURE);
    1048         }
    1049 
    1050         psFree(object);
    1051 
    1052         if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) {
    1053             psFree(md);
    1054             exit(EXIT_FAILURE);
    1055         }
    1056 
    1057         psFree(md);
    1058     }
    1059 
    1060     {
    1061         psMetadata      *md;
    1062         warpRunRow      *object;
    1063         bool            status;
    1064 
    1065         object = warpRunRowAlloc(-64, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z");
    1066         if (!object) {
    1067             exit(EXIT_FAILURE);
    1068         }
    1069 
    1070         md = warpRunMetadataFromObject(object);
    1071         if (!md) {
    1072             exit(EXIT_FAILURE);
    1073         }
    1074 
    1075         psFree(object);
    1076 
    1077             psFree(md);
    1078             exit(EXIT_FAILURE);
    1079         }
    1080         if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) {
    1081             psFree(md);
    1082             exit(EXIT_FAILURE);
    1083         }
    1084         if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    1085             psFree(md);
    1086             exit(EXIT_FAILURE);
    1087         }
    1088         if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    1089             psFree(md);
    1090             exit(EXIT_FAILURE);
    1091         }
    1092         if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
    1093             psFree(md);
    1094             exit(EXIT_FAILURE);
    1095         }
    1096             psFree(md);
    1097             exit(EXIT_FAILURE);
    1098         }
    1099 
    1100         psFree(md);
    1101     }
    1102 
    1103     {
    1104         psMetadata      *md;
    1105         warpInputExpRow *object;
    1106         bool            status;
    1107 
    1108         object = warpInputExpRowAlloc(-64, -64, true);
    1109         if (!object) {
    1110             exit(EXIT_FAILURE);
    1111         }
    1112 
    1113         md = warpInputExpMetadataFromObject(object);
    1114         if (!md) {
    1115             exit(EXIT_FAILURE);
    1116         }
    1117 
    1118         psFree(object);
    1119 
    1120             psFree(md);
    1121             exit(EXIT_FAILURE);
    1122         }
    1123             psFree(md);
    1124             exit(EXIT_FAILURE);
    1125         }
    1126         if (!psMetadataLookupBool(&status, md, "magiced") == true) {
    1127             psFree(md);
    1128             exit(EXIT_FAILURE);
    1129         }
    1130 
    1131         psFree(md);
    1132     }
    1133 
    1134     {
    1135         psMetadata      *md;
    1136         warpSkyCellMapRow *object;
    1137         bool            status;
    1138 
    1139         object = warpSkyCellMapRowAlloc(-64, "a string", "a string", -64, "a string", -16);
    1140         if (!object) {
    1141             exit(EXIT_FAILURE);
    1142         }
    1143 
    1144         md = warpSkyCellMapMetadataFromObject(object);
    1145         if (!md) {
    1146             exit(EXIT_FAILURE);
    1147         }
    1148 
    1149         psFree(object);
    1150 
    1151             psFree(md);
    1152             exit(EXIT_FAILURE);
    1153         }
    1154         if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
    1155             psFree(md);
    1156             exit(EXIT_FAILURE);
    1157         }
    1158         if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
    1159             psFree(md);
    1160             exit(EXIT_FAILURE);
    1161         }
    1162             psFree(md);
    1163             exit(EXIT_FAILURE);
    1164         }
    1165         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1166             psFree(md);
    1167             exit(EXIT_FAILURE);
    1168         }
    1169             psFree(md);
    1170             exit(EXIT_FAILURE);
    1171         }
    1172 
    1173         psFree(md);
    1174     }
    1175 
    1176     {
    1177         psMetadata      *md;
    1178         warpSkyfileRow  *object;
    1179         bool            status;
    1180 
    1181         object = warpSkyfileRowAlloc(-64, "a string", "a string", "a string", "a string", 64.64, 64.64);
    1182         if (!object) {
    1183             exit(EXIT_FAILURE);
    1184         }
    1185 
    1186         md = warpSkyfileMetadataFromObject(object);
    1187         if (!md) {
    1188             exit(EXIT_FAILURE);
    1189         }
    1190 
    1191         psFree(object);
    1192 
    1193             psFree(md);
    1194             exit(EXIT_FAILURE);
    1195         }
    1196         if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
    1197             psFree(md);
    1198             exit(EXIT_FAILURE);
    1199         }
    1200         if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     2672
     2673        psFree(md);
     2674    }
     2675
     2676    {
     2677        psMetadata      *md;
     2678        magicMaskRow    *object;
     2679        bool            status;
     2680
     2681        object = magicMaskRowAlloc(-64, "a string");
     2682        if (!object) {
     2683            exit(EXIT_FAILURE);
     2684        }
     2685
     2686        md = magicMaskMetadataFromObject(object);
     2687        if (!md) {
     2688            exit(EXIT_FAILURE);
     2689        }
     2690
     2691        psFree(object);
     2692
    12012693            psFree(md);
    12022694            exit(EXIT_FAILURE);
    … …  
    12062698            exit(EXIT_FAILURE);
    12072699        }
    1208         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1209             psFree(md);
    1210             exit(EXIT_FAILURE);
    1211         }
    1212         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1213             psFree(md);
    1214             exit(EXIT_FAILURE);
    1215         }
    1216         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1217             psFree(md);
    1218             exit(EXIT_FAILURE);
    1219         }
    1220 
    1221         psFree(md);
    1222     }
    1223 
    1224     {
    1225         psMetadata      *md;
    1226         diffRunRow      *object;
    1227         bool            status;
    1228 
    1229         object = diffRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string");
    1230         if (!object) {
    1231             exit(EXIT_FAILURE);
    1232         }
    1233 
    1234         md = diffRunMetadataFromObject(object);
    1235         if (!md) {
    1236             exit(EXIT_FAILURE);
    1237         }
    1238 
    1239         psFree(object);
    1240 
    1241             psFree(md);
    1242             exit(EXIT_FAILURE);
    1243         }
    1244         if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    1245             psFree(md);
    1246             exit(EXIT_FAILURE);
    1247         }
    1248         if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    1249             psFree(md);
    1250             exit(EXIT_FAILURE);
    1251         }
    1252         if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
    1253             psFree(md);
    1254             exit(EXIT_FAILURE);
    1255         }
    1256             psFree(md);
    1257             exit(EXIT_FAILURE);
    1258         }
    1259         if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
    1260             psFree(md);
    1261             exit(EXIT_FAILURE);
    1262         }
    1263         if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
    1264             psFree(md);
    1265             exit(EXIT_FAILURE);
    1266         }
    1267 
    1268         psFree(md);
    1269     }
    1270 
    1271     {
    1272         psMetadata      *md;
    1273         diffInputSkyfileRow *object;
    1274         bool            status;
    1275 
    1276         object = diffInputSkyfileRowAlloc(-64, -64, "a string", "a string", "a string", true);
    1277         if (!object) {
    1278             exit(EXIT_FAILURE);
    1279         }
    1280 
    1281         md = diffInputSkyfileMetadataFromObject(object);
    1282         if (!md) {
    1283             exit(EXIT_FAILURE);
    1284         }
    1285 
    1286         psFree(object);
    1287 
    1288             psFree(md);
    1289             exit(EXIT_FAILURE);
    1290         }
    1291             psFree(md);
    1292             exit(EXIT_FAILURE);
    1293         }
    1294         if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
    1295             psFree(md);
    1296             exit(EXIT_FAILURE);
    1297         }
    1298         if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
    1299             psFree(md);
    1300             exit(EXIT_FAILURE);
    1301         }
    1302         if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) {
    1303             psFree(md);
    1304             exit(EXIT_FAILURE);
    1305         }
    1306         if (!psMetadataLookupBool(&status, md, "template") == true) {
    1307             psFree(md);
    1308             exit(EXIT_FAILURE);
    1309         }
    1310 
    1311         psFree(md);
    1312     }
    1313 
    1314     {
    1315         psMetadata      *md;
    1316         diffSkyfileRow  *object;
    1317         bool            status;
    1318 
    1319         object = diffSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64);
    1320         if (!object) {
    1321             exit(EXIT_FAILURE);
    1322         }
    1323 
    1324         md = diffSkyfileMetadataFromObject(object);
    1325         if (!md) {
    1326             exit(EXIT_FAILURE);
    1327         }
    1328 
    1329         psFree(object);
    1330 
     2700
     2701        psFree(md);
     2702    }
     2703
     2704    {
     2705        psMetadata      *md;
     2706        magicSkyfileMaskRow *object;
     2707        bool            status;
     2708
     2709        object = magicSkyfileMaskRowAlloc(-64, -64, "a string");
     2710        if (!object) {
     2711            exit(EXIT_FAILURE);
     2712        }
     2713
     2714        md = magicSkyfileMaskMetadataFromObject(object);
     2715        if (!md) {
     2716            exit(EXIT_FAILURE);
     2717        }
     2718
     2719        psFree(object);
     2720
     2721            psFree(md);
     2722            exit(EXIT_FAILURE);
     2723        }
    13312724            psFree(md);
    13322725            exit(EXIT_FAILURE);
    13332726        }
    13342727        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1335             psFree(md);
    1336             exit(EXIT_FAILURE);
    1337         }
    1338         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1339             psFree(md);
    1340             exit(EXIT_FAILURE);
    1341         }
    1342         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1343             psFree(md);
    1344             exit(EXIT_FAILURE);
    1345         }
    1346         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1347             psFree(md);
    1348             exit(EXIT_FAILURE);
    1349         }
    1350 
    1351         psFree(md);
    1352     }
    1353 
    1354     {
    1355         psMetadata      *md;
    1356         stackRunRow     *object;
    1357         bool            status;
    1358 
    1359         object = stackRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string");
    1360         if (!object) {
    1361             exit(EXIT_FAILURE);
    1362         }
    1363 
    1364         md = stackRunMetadataFromObject(object);
    1365         if (!md) {
    1366             exit(EXIT_FAILURE);
    1367         }
    1368 
    1369         psFree(object);
    1370 
    1371             psFree(md);
    1372             exit(EXIT_FAILURE);
    1373         }
    1374         if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    1375             psFree(md);
    1376             exit(EXIT_FAILURE);
    1377         }
    1378         if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    1379             psFree(md);
    1380             exit(EXIT_FAILURE);
    1381         }
    1382         if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) {
    1383             psFree(md);
    1384             exit(EXIT_FAILURE);
    1385         }
    1386             psFree(md);
    1387             exit(EXIT_FAILURE);
    1388         }
    1389         if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
    1390             psFree(md);
    1391             exit(EXIT_FAILURE);
    1392         }
    1393         if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
    1394             psFree(md);
    1395             exit(EXIT_FAILURE);
    1396         }
    1397 
    1398         psFree(md);
    1399     }
    1400 
    1401     {
    1402         psMetadata      *md;
    1403         stackInputSkyfileRow *object;
    1404         bool            status;
    1405 
    1406         object = stackInputSkyfileRowAlloc(-64, -64);
    1407         if (!object) {
    1408             exit(EXIT_FAILURE);
    1409         }
    1410 
    1411         md = stackInputSkyfileMetadataFromObject(object);
    1412         if (!md) {
    1413             exit(EXIT_FAILURE);
    1414         }
    1415 
    1416         psFree(object);
    1417 
    1418             psFree(md);
    1419             exit(EXIT_FAILURE);
    1420         }
    1421             psFree(md);
    1422             exit(EXIT_FAILURE);
    1423         }
    1424 
    1425         psFree(md);
    1426     }
    1427 
    1428     {
    1429         psMetadata      *md;
    1430         stackSumSkyfileRow *object;
    1431         bool            status;
    1432 
    1433         object = stackSumSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64);
    1434         if (!object) {
    1435             exit(EXIT_FAILURE);
    1436         }
    1437 
    1438         md = stackSumSkyfileMetadataFromObject(object);
    1439         if (!md) {
    1440             exit(EXIT_FAILURE);
    1441         }
    1442 
    1443         psFree(object);
    1444 
    1445             psFree(md);
    1446             exit(EXIT_FAILURE);
    1447         }
    1448         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1449             psFree(md);
    1450             exit(EXIT_FAILURE);
    1451         }
    1452         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1453             psFree(md);
    1454             exit(EXIT_FAILURE);
    1455         }
    1456         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1457             psFree(md);
    1458             exit(EXIT_FAILURE);
    1459         }
    1460         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1461             psFree(md);
    1462             exit(EXIT_FAILURE);
    1463         }
    1464 
    1465         psFree(md);
    1466     }
    1467 
    1468     {
    1469         psMetadata      *md;
    1470         detRunRow       *object;
    1471         bool            status;
    1472 
    1473         object = detRunRowAlloc(-64, -32, "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 64.64, 64.64, "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", 32.32, 32.32, "a string", -32);
    1474         if (!object) {
    1475             exit(EXIT_FAILURE);
    1476         }
    1477 
    1478         md = detRunMetadataFromObject(object);
    1479         if (!md) {
    1480             exit(EXIT_FAILURE);
    1481         }
    1482 
    1483         psFree(object);
    1484 
    1485             psFree(md);
    1486             exit(EXIT_FAILURE);
    1487         }
    1488         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    1489             psFree(md);
    1490             exit(EXIT_FAILURE);
    1491         }
    1492         if (strncmp(psMetadataLookupPtr(&status, md, "det_type"), "a string", MAX_STRING_LENGTH)) {
    1493             psFree(md);
    1494             exit(EXIT_FAILURE);
    1495         }
    1496         if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) {
    1497             psFree(md);
    1498             exit(EXIT_FAILURE);
    1499         }
    1500         if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    1501             psFree(md);
    1502             exit(EXIT_FAILURE);
    1503         }
    1504         if (strncmp(psMetadataLookupPtr(&status, md, "filelevel"), "a string", MAX_STRING_LENGTH)) {
    1505             psFree(md);
    1506             exit(EXIT_FAILURE);
    1507         }
    1508         if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    1509             psFree(md);
    1510             exit(EXIT_FAILURE);
    1511         }
    1512         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    1513             psFree(md);
    1514             exit(EXIT_FAILURE);
    1515         }
    1516         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
    1517             psFree(md);
    1518             exit(EXIT_FAILURE);
    1519         }
    1520         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    1521             psFree(md);
    1522             exit(EXIT_FAILURE);
    1523         }
    1524         if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) {
    1525             psFree(md);
    1526             exit(EXIT_FAILURE);
    1527         }
    1528         if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    1529             psFree(md);
    1530             exit(EXIT_FAILURE);
    1531         }
    1532         if (!psMetadataLookupF32(&status, md, "airmass_min") == 32.32) {
    1533             psFree(md);
    1534             exit(EXIT_FAILURE);
    1535         }
    1536         if (!psMetadataLookupF32(&status, md, "airmass_max") == 32.32) {
    1537             psFree(md);
    1538             exit(EXIT_FAILURE);
    1539         }
    1540         if (!psMetadataLookupF32(&status, md, "exp_time_min") == 32.32) {
    1541             psFree(md);
    1542             exit(EXIT_FAILURE);
    1543         }
    1544         if (!psMetadataLookupF32(&status, md, "exp_time_max") == 32.32) {
    1545             psFree(md);
    1546             exit(EXIT_FAILURE);
    1547         }
    1548         if (!psMetadataLookupF32(&status, md, "ccd_temp_min") == 32.32) {
    1549             psFree(md);
    1550             exit(EXIT_FAILURE);
    1551         }
    1552         if (!psMetadataLookupF32(&status, md, "ccd_temp_max") == 32.32) {
    1553             psFree(md);
    1554             exit(EXIT_FAILURE);
    1555         }
    1556         if (!psMetadataLookupF64(&status, md, "posang_min") == 64.64) {
    1557             psFree(md);
    1558             exit(EXIT_FAILURE);
    1559         }
    1560         if (!psMetadataLookupF64(&status, md, "posang_max") == 64.64) {
    1561             psFree(md);
    1562             exit(EXIT_FAILURE);
    1563         }
    1564             psFree(md);
    1565             exit(EXIT_FAILURE);
    1566         }
    1567             psFree(md);
    1568             exit(EXIT_FAILURE);
    1569         }
    1570             psFree(md);
    1571             exit(EXIT_FAILURE);
    1572         }
    1573             psFree(md);
    1574             exit(EXIT_FAILURE);
    1575         }
    1576             psFree(md);
    1577             exit(EXIT_FAILURE);
    1578         }
    1579         if (!psMetadataLookupF32(&status, md, "solang_min") == 32.32) {
    1580             psFree(md);
    1581             exit(EXIT_FAILURE);
    1582         }
    1583         if (!psMetadataLookupF32(&status, md, "solang_max") == 32.32) {
    1584             psFree(md);
    1585             exit(EXIT_FAILURE);
    1586         }
    1587         if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) {
    1588             psFree(md);
    1589             exit(EXIT_FAILURE);
    1590         }
    1591         if (!psMetadataLookupS32(&status, md, "parent") == -32) {
    1592             psFree(md);
    1593             exit(EXIT_FAILURE);
    1594         }
    1595 
    1596         psFree(md);
    1597     }
    1598 
    1599     {
    1600         psMetadata      *md;
    1601         detInputExpRow  *object;
    1602         bool            status;
    1603 
    1604         object = detInputExpRowAlloc(-64, -32, -64, true);
    1605         if (!object) {
    1606             exit(EXIT_FAILURE);
    1607         }
    1608 
    1609         md = detInputExpMetadataFromObject(object);
    1610         if (!md) {
    1611             exit(EXIT_FAILURE);
    1612         }
    1613 
    1614         psFree(object);
    1615 
    1616             psFree(md);
    1617             exit(EXIT_FAILURE);
    1618         }
    1619         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    1620             psFree(md);
    1621             exit(EXIT_FAILURE);
    1622         }
    1623             psFree(md);
    1624             exit(EXIT_FAILURE);
    1625         }
    1626         if (!psMetadataLookupBool(&status, md, "include") == true) {
    1627             psFree(md);
    1628             exit(EXIT_FAILURE);
    1629         }
    1630 
    1631         psFree(md);
    1632     }
    1633 
    1634     {
    1635         psMetadata      *md;
    1636         detProcessedImfileRow *object;
    1637         bool            status;
    1638 
    1639         object = detProcessedImfileRowAlloc(-64, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
    1640         if (!object) {
    1641             exit(EXIT_FAILURE);
    1642         }
    1643 
    1644         md = detProcessedImfileMetadataFromObject(object);
    1645         if (!md) {
    1646             exit(EXIT_FAILURE);
    1647         }
    1648 
    1649         psFree(object);
    1650 
    1651             psFree(md);
    1652             exit(EXIT_FAILURE);
    1653         }
    1654             psFree(md);
    1655             exit(EXIT_FAILURE);
    1656         }
    1657         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1658             psFree(md);
    1659             exit(EXIT_FAILURE);
    1660         }
    1661         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1662             psFree(md);
    1663             exit(EXIT_FAILURE);
    1664         }
    1665         if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
    1666             psFree(md);
    1667             exit(EXIT_FAILURE);
    1668         }
    1669         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1670             psFree(md);
    1671             exit(EXIT_FAILURE);
    1672         }
    1673         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1674             psFree(md);
    1675             exit(EXIT_FAILURE);
    1676         }
    1677         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    1678             psFree(md);
    1679             exit(EXIT_FAILURE);
    1680         }
    1681         if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
    1682             psFree(md);
    1683             exit(EXIT_FAILURE);
    1684         }
    1685         if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
    1686             psFree(md);
    1687             exit(EXIT_FAILURE);
    1688         }
    1689         if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
    1690             psFree(md);
    1691             exit(EXIT_FAILURE);
    1692         }
    1693         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    1694             psFree(md);
    1695             exit(EXIT_FAILURE);
    1696         }
    1697         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    1698             psFree(md);
    1699             exit(EXIT_FAILURE);
    1700         }
    1701         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    1702             psFree(md);
    1703             exit(EXIT_FAILURE);
    1704         }
    1705         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    1706             psFree(md);
    1707             exit(EXIT_FAILURE);
    1708         }
    1709         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    1710             psFree(md);
    1711             exit(EXIT_FAILURE);
    1712         }
    1713         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1714             psFree(md);
    1715             exit(EXIT_FAILURE);
    1716         }
    1717             psFree(md);
    1718             exit(EXIT_FAILURE);
    1719         }
    1720 
    1721         psFree(md);
    1722     }
    1723 
    1724     {
    1725         psMetadata      *md;
    1726         detProcessedExpRow *object;
    1727         bool            status;
    1728 
    1729         object = detProcessedExpRowAlloc(-64, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
    1730         if (!object) {
    1731             exit(EXIT_FAILURE);
    1732         }
    1733 
    1734         md = detProcessedExpMetadataFromObject(object);
    1735         if (!md) {
    1736             exit(EXIT_FAILURE);
    1737         }
    1738 
    1739         psFree(object);
    1740 
    1741             psFree(md);
    1742             exit(EXIT_FAILURE);
    1743         }
    1744             psFree(md);
    1745             exit(EXIT_FAILURE);
    1746         }
    1747         if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
    1748             psFree(md);
    1749             exit(EXIT_FAILURE);
    1750         }
    1751         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1752             psFree(md);
    1753             exit(EXIT_FAILURE);
    1754         }
    1755         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1756             psFree(md);
    1757             exit(EXIT_FAILURE);
    1758         }
    1759         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    1760             psFree(md);
    1761             exit(EXIT_FAILURE);
    1762         }
    1763         if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
    1764             psFree(md);
    1765             exit(EXIT_FAILURE);
    1766         }
    1767         if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
    1768             psFree(md);
    1769             exit(EXIT_FAILURE);
    1770         }
    1771         if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
    1772             psFree(md);
    1773             exit(EXIT_FAILURE);
    1774         }
    1775         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    1776             psFree(md);
    1777             exit(EXIT_FAILURE);
    1778         }
    1779         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    1780             psFree(md);
    1781             exit(EXIT_FAILURE);
    1782         }
    1783         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    1784             psFree(md);
    1785             exit(EXIT_FAILURE);
    1786         }
    1787         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    1788             psFree(md);
    1789             exit(EXIT_FAILURE);
    1790         }
    1791         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    1792             psFree(md);
    1793             exit(EXIT_FAILURE);
    1794         }
    1795         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1796             psFree(md);
    1797             exit(EXIT_FAILURE);
    1798         }
    1799             psFree(md);
    1800             exit(EXIT_FAILURE);
    1801         }
    1802 
    1803         psFree(md);
    1804     }
    1805 
    1806     {
    1807         psMetadata      *md;
    1808         detStackedImfileRow *object;
    1809         bool            status;
    1810 
    1811         object = detStackedImfileRowAlloc(-64, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, -16);
    1812         if (!object) {
    1813             exit(EXIT_FAILURE);
    1814         }
    1815 
    1816         md = detStackedImfileMetadataFromObject(object);
    1817         if (!md) {
    1818             exit(EXIT_FAILURE);
    1819         }
    1820 
    1821         psFree(object);
    1822 
    1823             psFree(md);
    1824             exit(EXIT_FAILURE);
    1825         }
    1826         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    1827             psFree(md);
    1828             exit(EXIT_FAILURE);
    1829         }
    1830         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1831             psFree(md);
    1832             exit(EXIT_FAILURE);
    1833         }
    1834         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1835             psFree(md);
    1836             exit(EXIT_FAILURE);
    1837         }
    1838         if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
    1839             psFree(md);
    1840             exit(EXIT_FAILURE);
    1841         }
    1842         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1843             psFree(md);
    1844             exit(EXIT_FAILURE);
    1845         }
    1846         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1847             psFree(md);
    1848             exit(EXIT_FAILURE);
    1849         }
    1850         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    1851             psFree(md);
    1852             exit(EXIT_FAILURE);
    1853         }
    1854         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    1855             psFree(md);
    1856             exit(EXIT_FAILURE);
    1857         }
    1858         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    1859             psFree(md);
    1860             exit(EXIT_FAILURE);
    1861         }
    1862         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    1863             psFree(md);
    1864             exit(EXIT_FAILURE);
    1865         }
    1866         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    1867             psFree(md);
    1868             exit(EXIT_FAILURE);
    1869         }
    1870         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    1871             psFree(md);
    1872             exit(EXIT_FAILURE);
    1873         }
    1874             psFree(md);
    1875             exit(EXIT_FAILURE);
    1876         }
    1877 
    1878         psFree(md);
    1879     }
    1880 
    1881     {
    1882         psMetadata      *md;
    1883         detNormalizedStatImfileRow *object;
    1884         bool            status;
    1885 
    1886         object = detNormalizedStatImfileRowAlloc(-64, -32, "a string", 32.32, -16);
    1887         if (!object) {
    1888             exit(EXIT_FAILURE);
    1889         }
    1890 
    1891         md = detNormalizedStatImfileMetadataFromObject(object);
    1892         if (!md) {
    1893             exit(EXIT_FAILURE);
    1894         }
    1895 
    1896         psFree(object);
    1897 
    1898             psFree(md);
    1899             exit(EXIT_FAILURE);
    1900         }
    1901         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    1902             psFree(md);
    1903             exit(EXIT_FAILURE);
    1904         }
    1905         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1906             psFree(md);
    1907             exit(EXIT_FAILURE);
    1908         }
    1909         if (!psMetadataLookupF32(&status, md, "norm") == 32.32) {
    1910             psFree(md);
    1911             exit(EXIT_FAILURE);
    1912         }
    1913             psFree(md);
    1914             exit(EXIT_FAILURE);
    1915         }
    1916 
    1917         psFree(md);
    1918     }
    1919 
    1920     {
    1921         psMetadata      *md;
    1922         detNormalizedImfileRow *object;
    1923         bool            status;
    1924 
    1925         object = detNormalizedImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
    1926         if (!object) {
    1927             exit(EXIT_FAILURE);
    1928         }
    1929 
    1930         md = detNormalizedImfileMetadataFromObject(object);
    1931         if (!md) {
    1932             exit(EXIT_FAILURE);
    1933         }
    1934 
    1935         psFree(object);
    1936 
    1937             psFree(md);
    1938             exit(EXIT_FAILURE);
    1939         }
    1940         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    1941             psFree(md);
    1942             exit(EXIT_FAILURE);
    1943         }
    1944         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1945             psFree(md);
    1946             exit(EXIT_FAILURE);
    1947         }
    1948         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1949             psFree(md);
    1950             exit(EXIT_FAILURE);
    1951         }
    1952         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    1953             psFree(md);
    1954             exit(EXIT_FAILURE);
    1955         }
    1956         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    1957             psFree(md);
    1958             exit(EXIT_FAILURE);
    1959         }
    1960         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    1961             psFree(md);
    1962             exit(EXIT_FAILURE);
    1963         }
    1964         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    1965             psFree(md);
    1966             exit(EXIT_FAILURE);
    1967         }
    1968         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    1969             psFree(md);
    1970             exit(EXIT_FAILURE);
    1971         }
    1972         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    1973             psFree(md);
    1974             exit(EXIT_FAILURE);
    1975         }
    1976         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    1977             psFree(md);
    1978             exit(EXIT_FAILURE);
    1979         }
    1980         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    1981             psFree(md);
    1982             exit(EXIT_FAILURE);
    1983         }
    1984         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1985             psFree(md);
    1986             exit(EXIT_FAILURE);
    1987         }
    1988             psFree(md);
    1989             exit(EXIT_FAILURE);
    1990         }
    1991 
    1992         psFree(md);
    1993     }
    1994 
    1995     {
    1996         psMetadata      *md;
    1997         detNormalizedExpRow *object;
    1998         bool            status;
    1999 
    2000         object = detNormalizedExpRowAlloc(-64, -32, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
    2001         if (!object) {
    2002             exit(EXIT_FAILURE);
    2003         }
    2004 
    2005         md = detNormalizedExpMetadataFromObject(object);
    2006         if (!md) {
    2007             exit(EXIT_FAILURE);
    2008         }
    2009 
    2010         psFree(object);
    2011 
    2012             psFree(md);
    2013             exit(EXIT_FAILURE);
    2014         }
    2015         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    2016             psFree(md);
    2017             exit(EXIT_FAILURE);
    2018         }
    2019         if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
    2020             psFree(md);
    2021             exit(EXIT_FAILURE);
    2022         }
    2023         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    2024             psFree(md);
    2025             exit(EXIT_FAILURE);
    2026         }
    2027         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    2028             psFree(md);
    2029             exit(EXIT_FAILURE);
    2030         }
    2031         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    2032             psFree(md);
    2033             exit(EXIT_FAILURE);
    2034         }
    2035         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    2036             psFree(md);
    2037             exit(EXIT_FAILURE);
    2038         }
    2039         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    2040             psFree(md);
    2041             exit(EXIT_FAILURE);
    2042         }
    2043         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    2044             psFree(md);
    2045             exit(EXIT_FAILURE);
    2046         }
    2047         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    2048             psFree(md);
    2049             exit(EXIT_FAILURE);
    2050         }
    2051         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    2052             psFree(md);
    2053             exit(EXIT_FAILURE);
    2054         }
    2055         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    2056             psFree(md);
    2057             exit(EXIT_FAILURE);
    2058         }
    2059             psFree(md);
    2060             exit(EXIT_FAILURE);
    2061         }
    2062 
    2063         psFree(md);
    2064     }
    2065 
    2066     {
    2067         psMetadata      *md;
    2068         detResidImfileRow *object;
    2069         bool            status;
    2070 
    2071         object = detResidImfileRowAlloc(-64, -32, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16);
    2072         if (!object) {
    2073             exit(EXIT_FAILURE);
    2074         }
    2075 
    2076         md = detResidImfileMetadataFromObject(object);
    2077         if (!md) {
    2078             exit(EXIT_FAILURE);
    2079         }
    2080 
    2081         psFree(object);
    2082 
    2083             psFree(md);
    2084             exit(EXIT_FAILURE);
    2085         }
    2086         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    2087             psFree(md);
    2088             exit(EXIT_FAILURE);
    2089         }
    2090             psFree(md);
    2091             exit(EXIT_FAILURE);
    2092         }
    2093         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    2094             psFree(md);
    2095             exit(EXIT_FAILURE);
    2096         }
    2097         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    2098             psFree(md);
    2099             exit(EXIT_FAILURE);
    2100         }
    2101         if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
    2102             psFree(md);
    2103             exit(EXIT_FAILURE);
    2104         }
    2105         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    2106             psFree(md);
    2107             exit(EXIT_FAILURE);
    2108         }
    2109         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    2110             psFree(md);
    2111             exit(EXIT_FAILURE);
    2112         }
    2113         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    2114             psFree(md);
    2115             exit(EXIT_FAILURE);
    2116         }
    2117         if (!psMetadataLookupF64(&status, md, "bin_stdev") == 64.64) {
    2118             psFree(md);
    2119             exit(EXIT_FAILURE);
    2120         }
    2121         if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
    2122             psFree(md);
    2123             exit(EXIT_FAILURE);
    2124         }
    2125         if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
    2126             psFree(md);
    2127             exit(EXIT_FAILURE);
    2128         }
    2129         if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
    2130             psFree(md);
    2131             exit(EXIT_FAILURE);
    2132         }
    2133         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    2134             psFree(md);
    2135             exit(EXIT_FAILURE);
    2136         }
    2137         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    2138             psFree(md);
    2139             exit(EXIT_FAILURE);
    2140         }
    2141         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    2142             psFree(md);
    2143             exit(EXIT_FAILURE);
    2144         }
    2145         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    2146             psFree(md);
    2147             exit(EXIT_FAILURE);
    2148         }
    2149         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    2150             psFree(md);
    2151             exit(EXIT_FAILURE);
    2152         }
    2153         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    2154             psFree(md);
    2155             exit(EXIT_FAILURE);
    2156         }
    2157             psFree(md);
    2158             exit(EXIT_FAILURE);
    2159         }
    2160 
    2161         psFree(md);
    2162     }
    2163 
    2164     {
    2165         psMetadata      *md;
    2166         detResidExpRow  *object;
    2167         bool            status;
    2168 
    2169         object = detResidExpRowAlloc(-64, -32, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", true, -16);
    2170         if (!object) {
    2171             exit(EXIT_FAILURE);
    2172         }
    2173 
    2174         md = detResidExpMetadataFromObject(object);
    2175         if (!md) {
    2176             exit(EXIT_FAILURE);
    2177         }
    2178 
    2179         psFree(object);
    2180 
    2181             psFree(md);
    2182             exit(EXIT_FAILURE);
    2183         }
    2184         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    2185             psFree(md);
    2186             exit(EXIT_FAILURE);
    2187         }
    2188             psFree(md);
    2189             exit(EXIT_FAILURE);
    2190         }
    2191         if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) {
    2192             psFree(md);
    2193             exit(EXIT_FAILURE);
    2194         }
    2195         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    2196             psFree(md);
    2197             exit(EXIT_FAILURE);
    2198         }
    2199         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    2200             psFree(md);
    2201             exit(EXIT_FAILURE);
    2202         }
    2203         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    2204             psFree(md);
    2205             exit(EXIT_FAILURE);
    2206         }
    2207         if (!psMetadataLookupF64(&status, md, "bin_stdev") == 64.64) {
    2208             psFree(md);
    2209             exit(EXIT_FAILURE);
    2210         }
    2211         if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) {
    2212             psFree(md);
    2213             exit(EXIT_FAILURE);
    2214         }
    2215         if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) {
    2216             psFree(md);
    2217             exit(EXIT_FAILURE);
    2218         }
    2219         if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) {
    2220             psFree(md);
    2221             exit(EXIT_FAILURE);
    2222         }
    2223         if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) {
    2224             psFree(md);
    2225             exit(EXIT_FAILURE);
    2226         }
    2227         if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) {
    2228             psFree(md);
    2229             exit(EXIT_FAILURE);
    2230         }
    2231         if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) {
    2232             psFree(md);
    2233             exit(EXIT_FAILURE);
    2234         }
    2235         if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) {
    2236             psFree(md);
    2237             exit(EXIT_FAILURE);
    2238         }
    2239         if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) {
    2240             psFree(md);
    2241             exit(EXIT_FAILURE);
    2242         }
    2243         if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    2244             psFree(md);
    2245             exit(EXIT_FAILURE);
    2246         }
    2247         if (!psMetadataLookupBool(&status, md, "accept") == true) {
    2248             psFree(md);
    2249             exit(EXIT_FAILURE);
    2250         }
    2251             psFree(md);
    2252             exit(EXIT_FAILURE);
    2253         }
    2254 
    2255         psFree(md);
    2256     }
    2257 
    2258     {
    2259         psMetadata      *md;
    2260         detRunSummaryRow *object;
    2261         bool            status;
    2262 
    2263         object = detRunSummaryRowAlloc(-64, -32, 64.64, 64.64, 64.64, true, -16);
    2264         if (!object) {
    2265             exit(EXIT_FAILURE);
    2266         }
    2267 
    2268         md = detRunSummaryMetadataFromObject(object);
    2269         if (!md) {
    2270             exit(EXIT_FAILURE);
    2271         }
    2272 
    2273         psFree(object);
    2274 
    2275             psFree(md);
    2276             exit(EXIT_FAILURE);
    2277         }
    2278         if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    2279             psFree(md);
    2280             exit(EXIT_FAILURE);
    2281         }
    2282         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    2283             psFree(md);
    2284             exit(EXIT_FAILURE);
    2285         }
    2286         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    2287             psFree(md);
    2288             exit(EXIT_FAILURE);
    2289         }
    2290         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    2291             psFree(md);
    2292             exit(EXIT_FAILURE);
    2293         }
    2294         if (!psMetadataLookupBool(&status, md, "accept") == true) {
    2295             psFree(md);
    2296             exit(EXIT_FAILURE);
    2297         }
    22982728            psFree(md);
    22992729            exit(EXIT_FAILURE);
Note: See TracChangeset for help on using the changeset viewer.