IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 3, 2004, 1:19:07 PM (22 years ago)
Author:
harman
Message:

Updates for version 10 of SDRS

Location:
trunk/psLib/test/collections
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/collections/tst_psMetadataIO.c

    r2392 r2607  
    1313*  @author  Ross Harman, MHPCC
    1414*
    15 *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
    16 *  @date  $Date: 2004-11-22 20:53:39 $
     15*  @version $Revision: 1.5 $  $Name: not supported by cvs2svn $
     16*  @date  $Date: 2004-12-03 23:19:07 $
    1717*
    1818*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2525
    2626static void printMetadataItem(psMetadataItem *metadataItem, char *spaces);
     27static void printMetadata(psMetadata *metadata);
     28static void printMetadataList(psList *metadataItemList, char* spaces);
     29static void printMetadataTable(psHash *mdTable);
    2730
    28 static void printMetadataItemList(psList *metadataItemList)
     31static void printMetadata(psMetadata *metadata)
     32{
     33    printf("Contents of metadata list:\n");
     34    printMetadataList(metadata->list, " ");
     35    printf("\nContents of metadata table:\n");
     36    printMetadataTable(metadata->table);
     37}
     38
     39static void printMetadataList(psList *metadataItemList, char* spaces)
    2940{
    3041    psMetadataItem *entryChild = NULL;
    … …  
    3344    entryChild = psListGetCurrent(metadataItemList);
    3445    while (entryChild != NULL) {
    35         printMetadataItem(entryChild, "    ");
     46        printMetadataItem(entryChild, spaces);
    3647        entryChild = psListGetNext(metadataItemList);
    37     }
    38 }
    39 
    40 static void printMetadataList(psList *metadataItemList)
    41 {
    42     psMetadataItem *entryChild = NULL;
    43 
    44     psListSetIterator(metadataItemList, PS_LIST_HEAD);
    45     entryChild = psListGetCurrent(metadataItemList);
    46     while (entryChild != NULL) {
    47         printMetadataItem(entryChild, " ");
    48         entryChild = psListGetNext(metadataItemList);
    49     }
    50 }
    51 static void printMetadataItem(psMetadataItem *metadataItem, char *spaces)
    52 {
    53 
    54     psVector *vec = NULL;
    55 
    56 
    57     printf("%sKey Name: %8s  ", spaces, metadataItem->name);
    58     printf("Key Type: %2d  ", metadataItem->type);
    59 
    60     switch (metadataItem->type ) {
    61     case PS_META_ITEM_SET:
    62         printf("Key Value: %17c", ' ');
    63         break;
    64     case PS_META_BOOL:
    65         printf("Key Value: %15d  ", metadataItem->data.B);
    66         break;
    67     case PS_META_S32:
    68         printf("Key Value: %15d  ", metadataItem->data.S32);
    69         break;
    70     case PS_META_F32:
    71         printf("Key Value: %15.3f  ", metadataItem->data.F32);
    72         break;
    73     case PS_META_F64:
    74         printf("Key Value: %15.3f  ", metadataItem->data.F64);
    75         break;
    76     case PS_META_STR:
    77         printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    78         break;
    79     case PS_META_VEC:
    80         vec = (psVector*)metadataItem->data.V;
    81         printf("Key Value: ");
    82         for(psS32 i=0; i<vec->nalloc;i++) {
    83             printf("%d ", vec->data.S32[i]);
    84         }
    85         break;
    86     case PS_META_IMG:
    87     case PS_META_JPEG:
    88     case PS_META_PNG:
    89     case PS_META_ASTROM:
    90     case PS_META_UNKNOWN:
    91         printf("Value: unknown ");
    92         break;
    93     default:
    94         printf("Bad type: %d ", metadataItem->type);
    95     }
    96     printf("Key Comment: %s\n", metadataItem->comment);
    97 
    98     if(metadataItem->items->size) {
    99         printMetadataItemList(metadataItem->items);
    10048    }
    10149}
    … …  
    11462}
    11563
    116 static void printMetadata(psMetadata *metadata)
     64static void printMetadataItem(psMetadataItem *metadataItem, char *spaces)
    11765{
    118     printf("\nContents of metadata list:\n");
    119     printMetadataList(metadata->list);
    120     printf("\nContents of metadata table:\n");
    121     printMetadataTable(metadata->table);
     66    printf("%sKey Name: %8s  ", spaces, metadataItem->name);
     67    printf("Key pType: %d  ", metadataItem->pType);
     68    printf("Key mdType: %d  ", metadataItem->type);
     69
     70    switch (metadataItem->type) {
     71    case PS_META_LIST:
     72        printf("Key Value: %17c", ' ');
     73        break;
     74    case PS_META_PRIMITIVE:
     75        switch(metadataItem->pType) {
     76        case PS_TYPE_BOOL:
     77            printf("Key Value: %15d  ", metadataItem->data.B);
     78            break;
     79        case PS_TYPE_S32:
     80            printf("Key Value: %15d  ", metadataItem->data.S32);
     81            break;
     82        case PS_TYPE_F32:
     83            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     84            break;
     85        case PS_TYPE_F64:
     86            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     87            break;
     88        default:
     89            printf("Bad type: %d ", metadataItem->pType);
     90        }
     91        break;
     92    case PS_META_STR:
     93        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
     94        break;
     95    default:
     96        printf("Bad type: %d ", metadataItem->type);
     97    }
     98    printf("Key Comment: %s\n", metadataItem->comment);
     99
     100    if(metadataItem->data.V && metadataItem->type==PS_META_LIST) {
     101        printMetadataList(metadataItem->data.V, "    ");
     102    }
    122103}
    123104
    … …  
    128109    printPositiveTestHeader(stdout, "psMetadata", "Test A - Read config file with overwrite set true");
    129110    psMetadata *metadata1 = NULL;
    130     psS32 failedLines1 = 0;
    131     failedLines1 = psMetadataParseConfig(&metadata1, "test.config", true);
     111    psU32 failedLines1 = 0;
     112    metadata1 = psMetadataParseConfig(metadata1, &failedLines1, "test.config", true);
    132113    printf("Failed lines: %d Expected: 6\n", failedLines1);
    133114    printMetadata(metadata1);
    … …  
    139120    psMetadata *metadata2 = NULL;
    140121    psS32 failedLines2 = 0;
    141     failedLines2 = psMetadataParseConfig(&metadata2, "test.config", false);
    142     printf("Failed lines: %d Expected: 7", failedLines2);
     122    metadata2 = psMetadataParseConfig(metadata2, &failedLines2, "test.config", false);
     123    printf("Failed lines: %d Expected: 7 ", failedLines2);
    143124    printMetadata(metadata2);
    144125    printFooter(stdout, "psMetadata", "Test B - Read config file with overwrite set false", true);
    … …  
    149130    psMetadata *metadata3 = psMetadataAlloc();
    150131    psS32 failedLines3 = 0;
    151     failedLines3 = psMetadataParseConfig(&metadata3, "test.config", false);
    152     printf("Failed lines: %d Expected: 7", failedLines3);
     132    metadata3 = psMetadataParseConfig(metadata3, &failedLines3, "test.config", true);
     133    printf("Failed lines: %d Expected: 6 ", failedLines3);
    153134    printMetadata(metadata3);
    154135    printFooter(stdout, "psMetadata", "Test C - Read config file without auto-allocation of metadata", true);
    … …  
    158139    printNegativeTestHeader(stdout,"psMetadataIO", "Test D - Attempt to use null fileName argument",
    159140                            "Null failedLines not allowed", 0);
    160     psMetadataParseConfig(&metadata1, NULL, true);
     141    psMetadataParseConfig(metadata1, &failedLines1, NULL, true);
    161142    printFooter(stdout, "psMetadata", "Test D - Attempt to use null fileName argument", true);
    162143
    … …  
    165146    printNegativeTestHeader(stdout,"psMetadataIO", "Test E - Attempt to open nonexistant file",
    166147                            "Error opening file", 0);
    167     psMetadataParseConfig(&metadata1, "abcedfg", true);
     148    psMetadataParseConfig(metadata1, &failedLines1, "abcedfg", true);
    168149    printFooter(stdout, "psMetadata", "Test E - Attempt to open nonexistant file", true);
    169150

  • trunk/psLib/test/collections/tst_psMetadata_01.c

    r2392 r2607  
    1313*     Test H - Attempt to use bad extNum
    1414*     Test I - Attempt to use bad extNameTest
    15 *     Test J - Free psMetadataData
     15*     Test J - Read named hdr w/ invalid extnum
     16*     Test K - Free psMetadata
    1617*
    1718*  @author  Ross Harman, MHPCC
    1819*
    19 *  @version $Revision: 1.15 $  $Name: not supported by cvs2svn $
    20 *  @date  $Date: 2004-11-22 20:54:50 $
     20*  @version $Revision: 1.16 $  $Name: not supported by cvs2svn $
     21*  @date  $Date: 2004-12-03 23:19:07 $
    2122*
    2223*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2930
    3031static void printMetadataItem(psMetadataItem *metadataItem, char *spaces);
    31 
    32 static void printMetadataItemList(psList *metadataItemList)
     32static void printMetadata(psMetadata *metadata);
     33static void printMetadataList(psList *metadataItemList, char* spaces);
     34static void printMetadataTable(psHash *mdTable);
     35
     36static void printMetadata(psMetadata *metadata)
     37{
     38    printf("Contents of metadata list:\n");
     39    printMetadataList(metadata->list, " ");
     40    printf("\nContents of metadata table:\n");
     41    printMetadataTable(metadata->table);
     42}
     43
     44static void printMetadataList(psList *metadataItemList, char* spaces)
    3345{
    3446    psMetadataItem *entryChild = NULL;
    … …  
    3749    entryChild = psListGetCurrent(metadataItemList);
    3850    while (entryChild != NULL) {
    39         printMetadataItem(entryChild, "    ");
     51        printMetadataItem(entryChild, spaces);
    4052        entryChild = psListGetNext(metadataItemList);
    41     }
    42 }
    43 
    44 static void printMetadataList(psList *metadataItemList)
    45 {
    46     psMetadataItem *entryChild = NULL;
    47 
    48     psListSetIterator(metadataItemList, PS_LIST_HEAD);
    49     entryChild = psListGetCurrent(metadataItemList);
    50     while (entryChild != NULL) {
    51         printMetadataItem(entryChild, " ");
    52         entryChild = psListGetNext(metadataItemList);
    53     }
    54 }
    55 static void printMetadataItem(psMetadataItem *metadataItem, char *spaces)
    56 {
    57     printf("%sKey Name: %8s  ", spaces, metadataItem->name);
    58     printf("Key Type: %2d  ", metadataItem->type);
    59 
    60     switch (metadataItem->type ) {
    61     case PS_META_ITEM_SET:
    62         printf("Key Value: %17c", ' ');
    63         break;
    64     case PS_META_BOOL:
    65         printf("Key Value: %15d  ", metadataItem->data.B);
    66         break;
    67     case PS_META_S32:
    68         printf("Key Value: %15d  ", metadataItem->data.S32);
    69         break;
    70     case PS_META_F32:
    71         printf("Key Value: %15.3f  ", metadataItem->data.F32);
    72         break;
    73     case PS_META_F64:
    74         printf("Key Value: %15.3f  ", metadataItem->data.F64);
    75         break;
    76     case PS_META_STR:
    77         printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    78         break;
    79     case PS_META_IMG:
    80     case PS_META_JPEG:
    81     case PS_META_PNG:
    82     case PS_META_ASTROM:
    83     case PS_META_UNKNOWN:
    84         printf("Value: unknown ");
    85         break;
    86     default:
    87         printf("Bad type: %d ", metadataItem->type);
    88     }
    89     printf("Key Comment: %s\n", metadataItem->comment);
    90 
    91     if(metadataItem->items->size) {
    92         printMetadataItemList(metadataItem->items);
    9353    }
    9454}
    … …  
    10767}
    10868
    109 static void printMetadata(psMetadata *metadata)
    110 {
    111     printf("Contents of metadata list:\n");
    112     printMetadataList(metadata->list);
    113     printf("\nContents of metadata table:\n");
    114     printMetadataTable(metadata->table);
     69static void printMetadataItem(psMetadataItem *metadataItem, char *spaces)
     70{
     71    printf("%sKey Name: %8s  ", spaces, metadataItem->name);
     72    printf("Key pType: %d  ", metadataItem->pType);
     73    printf("Key mdType: %d  ", metadataItem->type);
     74
     75    switch (metadataItem->type) {
     76    case PS_META_LIST:
     77        printf("Key Value: %17c", ' ');
     78        break;
     79    case PS_META_PRIMITIVE:
     80        switch(metadataItem->pType) {
     81        case PS_TYPE_BOOL:
     82            printf("Key Value: %15d  ", metadataItem->data.B);
     83            break;
     84        case PS_TYPE_S32:
     85            printf("Key Value: %15d  ", metadataItem->data.S32);
     86            break;
     87        case PS_TYPE_F32:
     88            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     89            break;
     90        case PS_TYPE_F64:
     91            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     92            break;
     93        default:
     94            printf("Bad type: %d ", metadataItem->pType);
     95        }
     96        break;
     97    case PS_META_STR:
     98        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
     99        break;
     100    default:
     101        printf("Bad type: %d ", metadataItem->type);
     102    }
     103    printf("Key Comment: %s\n", metadataItem->comment);
     104
     105    if(metadataItem->data.V && metadataItem->type==PS_META_LIST) {
     106        printMetadataList(metadataItem->data.V, "    ");
     107    }
    115108}
    116109
    … …  
    244237
    245238
    246     // Test I1 - Attempt to use a valid named extension with invalid extnum
    247     printNegativeTestHeader(stdout, "psMetadata", "Test I1 - Read named hdr w/ invalid extnum",
     239    // Test J - Read named hdr w/ invalid extnum
     240    printNegativeTestHeader(stdout, "psMetadata", "Test J - Read named hdr w/ invalid extnum",
    248241                            "If extName specified, extNum should be -1.", 0);
    249     metadata1 = psMetadataReadHeader(NULL, "MY_DATA_2", 0, "header_2.fits");
     242    metadata1 = psMetadataReadHeader(NULL, NULL, 0, "header_2.fits");
    250243    if (metadata1 != NULL ) {
    251244        psError(PS_ERR_UNKNOWN, true,"psMetadataReadHeader did not return null w/ valid extname, invalid extnum");
    252245        return 12;
    253246    }
    254     printFooter(stdout, "psMetadata", "Test C - Read named hdr from complex FITS file", true);
    255 
    256 
    257     // Test J - Free psMetadata
    258     printPositiveTestHeader(stdout, "psMetadata", "Test J - Free psMetadata");
     247    printFooter(stdout, "psMetadata", "Test J - Read named hdr w/ invalid extnum", true);
     248
     249
     250    // Test K - Free psMetadata
     251    printPositiveTestHeader(stdout, "psMetadata", "Test K - Free psMetadata");
    259252    psFree(metadata1);
    260253    psFree(metadata2);
    … …  
    262255    if(psMemCheckLeaks(0, NULL, stdout,false)) {
    263256        psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
    264         return 10;
    265257    }
    266258    psMemCheckCorruption(0);
    … …  
    269261        printf("ERROR: Found %d bad memory blocks\n", nBad);
    270262    }
    271     printFooter(stdout, "psMetadata", "Test J - Free psMetadata", true);
     263    printFooter(stdout, "psMetadata", "Test K - Free psMetadata", true);
    272264
    273265    return 0;

  • trunk/psLib/test/collections/tst_psMetadata_02.c

    r2392 r2607  
    1414*  @author  Ross Harman, MHPCC
    1515*
    16 *  @version $Revision: 1.8 $  $Name: not supported by cvs2svn $
    17 *  @date  $Date: 2004-11-22 20:54:50 $
     16*  @version $Revision: 1.9 $  $Name: not supported by cvs2svn $
     17*  @date  $Date: 2004-12-03 23:19:07 $
    1818*
    1919*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2525#include <string.h>
    2626
    27 static void printMetadataItem(psMetadataItem *item)
     27static void printMetadataItem(psMetadataItem *metadataItem)
    2828{
    29     printf("Key Name: %8s  ", item->name);
    30     printf("Key Type: %2d  ", item->type);
     29    printf("Key Name: %8s  ", metadataItem->name);
     30    printf("Key pType: %2d  ", metadataItem->pType);
     31    printf("Key mdType: %2d  ", metadataItem->type);
    3132
    32     switch (item->type ) {
    33     case PS_META_BOOL:
    34         printf("Key Value: %15d  ", item->data.B);
     33    switch (metadataItem->type) {
     34    case PS_META_LIST:
     35        printf("Key Value: %17c", ' ');
    3536        break;
    36     case PS_META_S32:
    37         printf("Key Value: %15d  ", item->data.S32);
    38         break;
    39     case PS_META_F32:
    40         printf("Key Value: %15.3f  ", item->data.F32);
    41         break;
    42     case PS_META_F64:
    43         printf("Key Value: %15.3f  ", item->data.F64);
     37    case PS_META_PRIMITIVE:
     38        switch(metadataItem->pType) {
     39        case PS_TYPE_BOOL:
     40            printf("Key Value: %15d  ", metadataItem->data.B);
     41            break;
     42        case PS_TYPE_S32:
     43            printf("Key Value: %15d  ", metadataItem->data.S32);
     44            break;
     45        case PS_TYPE_F32:
     46            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     47            break;
     48        case PS_TYPE_F64:
     49            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     50            break;
     51        default:
     52            printf("Bad type: %d ", metadataItem->pType);
     53        }
    4454        break;
    4555    case PS_META_STR:
    46         printf("Key Value: %15s  ", (char*)item->data.V);
    47         break;
    48     case PS_META_IMG:
    49     case PS_META_JPEG:
    50     case PS_META_PNG:
    51     case PS_META_ASTROM:
    52     case PS_META_UNKNOWN:
    53         printf("Value: unknown ");
     56        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    5457        break;
    5558    default:
    56         printf("Bad type: %d ", item->type);
     59        printf("Bad type: %d ", metadataItem->type);
    5760    }
    58     printf("Key Comment: %s\n", item->comment);
     61    printf("Key Comment: %s\n", metadataItem->comment);
    5962}
    6063
    … …  
    7376    // Test A - Allocate metadata items
    7477    printPositiveTestHeader(stdout, "psMetadata", "Test A - Allocate metadata items");
    75     item1 = psMetadataItemAlloc("myItem1", PS_META_BOOL, "I am a boolean", true);
    76     item2 = psMetadataItemAlloc("myItem2", PS_META_S32, "I am a signed integer", 111);
    77     item3 = psMetadataItemAlloc("myItem3", PS_META_F32, "I am a single precision floating point", 222.222);
    78     item4 = psMetadataItemAlloc("myItem4", PS_META_F64, "I am a double precision floating point", 333.333);
    79     item5 = psMetadataItemAlloc("myItem5", PS_META_STR, "I am a string", "HELLO WORLD");
     78    item1 = psMetadataItemAlloc("myItem1", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", true);
     79    item2 = psMetadataItemAlloc("myItem2", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a signed integer", 111);
     80    item3 = psMetadataItemAlloc("myItem3", PS_TYPE_F32, PS_META_PRIMITIVE, "I am a single precision floating point", 222.222);
     81    item4 = psMetadataItemAlloc("myItem4", PS_TYPE_F64, PS_META_PRIMITIVE, "I am a double precision floating point", 333.333);
     82    item5 = psMetadataItemAlloc("myItem5", PS_TYPE_PTR, PS_META_STR, "I am a string", "HELLO WORLD");
    8083    printMetadataItem(item1);
    8184    printMetadataItem(item2);
    … …  
    9093                            "Null value for name not allowed", 0);
    9194    psLogMsg(__func__,PS_LOG_INFO,"Following should produce error for null name.");
    92     badItem = psMetadataItemAlloc(NULL, PS_META_STR, "I am a string", "HELLO WORLD");
     95    badItem = psMetadataItemAlloc(NULL, PS_TYPE_PTR, PS_META_STR, "I am a string", "HELLO WORLD");
    9396    if (badItem != NULL) {
    9497        psError(PS_ERR_UNKNOWN, true,"psMetadataItemAlloc did not return null with null name item.");
    … …  
    101104    printNegativeTestHeader(stdout,"psMetadata", "Test C - Attempt to create metadata item with invalid type",
    102105                            "Invalid psMetadataType: 6", 0);
    103     badItem = psMetadataItemAlloc("badItem", PS_META_IMG, "I am bad", "Bad comment");
     106    badItem = psMetadataItemAlloc("badItem", PS_TYPE_PTR, PS_META_NTYPE, "I am bad", "Bad comment");
    104107    printFooter(stdout, "psMetadata", "Test C - Attempt to create metadata item with invalid type", true);
    105108

  • trunk/psLib/test/collections/tst_psMetadata_03.c

    r2392 r2607  
    1010*     Test E - Attempt to remove non-existant metadata item by name
    1111*     Test F - Attempt to remove non-existant metadata item by index
    12 *     Test G - Free psMetadata
    13  *
     12*     Test G - Attempt to add item to an invalid metadata structure
     13*     Test H - Attempt to add item to an invalid metadata structure
     14*     Test I - Attempt to add item with a null name
     15*     Test J - Attempt to add item to an invalid metadata structure
     16*     Test K - Free psMetadata
     17*
    1418*  @author  Ross Harman, MHPCC
    1519*
    16 *  @version $Revision: 1.10 $  $Name: not supported by cvs2svn $
    17 *  @date  $Date: 2004-11-22 20:54:50 $
     20*  @version $Revision: 1.11 $  $Name: not supported by cvs2svn $
     21*  @date  $Date: 2004-12-03 23:19:07 $
    1822*
    1923*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2529#include <string.h>
    2630
    27 static void printMetadataItem(psMetadataItem *item)
     31static void printMetadataItem(psMetadataItem *metadataItem)
    2832{
    29     printf("Key Name: %8s  ", item->name);
    30     printf("Key Type: %2d  ", item->type);
    31 
    32     switch (item->type ) {
    33     case PS_META_BOOL:
    34         printf("Key Value: %15d  ", item->data.B);
     33    printf("Key Name: %8s  ", metadataItem->name);
     34    printf("Key pType: %2d  ", metadataItem->pType);
     35    printf("Key mdType: %2d  ", metadataItem->type);
     36
     37    switch (metadataItem->type) {
     38    case PS_META_LIST:
     39        printf("Key Value: %17c", ' ');
    3540        break;
    36     case PS_META_S32:
    37         printf("Key Value: %15d  ", item->data.S32);
    38         break;
    39     case PS_META_F32:
    40         printf("Key Value: %15.3f  ", item->data.F32);
    41         break;
    42     case PS_META_F64:
    43         printf("Key Value: %15.3f  ", item->data.F64);
     41    case PS_META_PRIMITIVE:
     42        switch(metadataItem->pType) {
     43        case PS_TYPE_BOOL:
     44            printf("Key Value: %15d  ", metadataItem->data.B);
     45            break;
     46        case PS_TYPE_S32:
     47            printf("Key Value: %15d  ", metadataItem->data.S32);
     48            break;
     49        case PS_TYPE_F32:
     50            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     51            break;
     52        case PS_TYPE_F64:
     53            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     54            break;
     55        default:
     56            printf("Bad type: %d ", metadataItem->pType);
     57        }
    4458        break;
    4559    case PS_META_STR:
    46         printf("Key Value: %15s  ", (char*)item->data.V);
    47         break;
    48     case PS_META_IMG:
    49     case PS_META_JPEG:
    50     case PS_META_PNG:
    51     case PS_META_ASTROM:
    52     case PS_META_UNKNOWN:
    53         printf("Value: unknown ");
     60        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    5461        break;
    5562    default:
    56         printf("Bad type: %d ", item->type);
    57     }
    58     printf("Key Comment: %s\n", item->comment);
     63        printf("Bad type: %d ", metadataItem->type);
     64    }
     65    printf("Key Comment: %s\n", metadataItem->comment);
    5966}
    6067
    … …  
    7683    printPositiveTestHeader(stdout, "psMetadata", "Test A - Allocate metadata items");
    7784    metadata = psMetadataAlloc();
    78     item1 = psMetadataItemAlloc("myItem1", PS_META_BOOL, "I am a boolean", true);
    79     item2 = psMetadataItemAlloc("myItem2", PS_META_S32, "I am a integer", 55);
    80     item3 = psMetadataItemAlloc("myItem3", PS_META_BOOL, "I am a boolean", false);
    81     item4 = psMetadataItemAlloc("myItem4", PS_META_S32, "I am a integer", 66);
    82     errItem = psMetadataItemAlloc("errItem", PS_META_S32, "I am a integer", 99);
     85    item1 = psMetadataItemAlloc("myItem1", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", true);
     86    item2 = psMetadataItemAlloc("myItem2", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 55);
     87    item3 = psMetadataItemAlloc("myItem3", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", false);
     88    item4 = psMetadataItemAlloc("myItem4", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 66);
     89    errItem = psMetadataItemAlloc("errItem", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 99);
    8390    printMetadataItem(item1);
    8491    printMetadataItem(item2);
    … …  
    9097    // Test B - Remove items from metadata by name
    9198    printPositiveTestHeader(stdout, "psMetadata", "Test B - Remove items from metadata by name");
    92     if( ! psMetadataAddItem(metadata, item1, PS_LIST_HEAD) ) {
     99    if(!psMetadataAddItem(metadata, item1, PS_LIST_HEAD)) {
    93100        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem did not return true when adding by name.");
    94101        return 10;
    95102    }
    96     if( ! psMetadataAdd(metadata,PS_LIST_HEAD,"myItem2",PS_META_S32,"I am S32 integer",77) ) {
     103    if(!psMetadataAdd(metadata,PS_LIST_HEAD,"myItem2", PS_TYPE_S32, PS_META_PRIMITIVE, "I am S32 integer",77)) {
    97104        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem did not return true when adding by name.");
    98105        return 11;
    99106    }
    100     if ( ! psMetadataRemove(metadata, 0, "myItem1" ) ) {
     107    if (!psMetadataRemove(metadata, 0, "myItem1")) {
    101108        psError(PS_ERR_UNKNOWN, true,"psMetadataRemove did not return true when removing by name.");
    102109        return 12;
    103110    }
    104     if ( ! psMetadataRemove(metadata, 0, "myItem2" ) ) {
     111    if (!psMetadataRemove(metadata, 0, "myItem2")) {
    105112        psError(PS_ERR_UNKNOWN, true,"psMetadataRemove did not return true when removing by name.");
    106113        return 13;
    … …  
    115122        return 14;
    116123    }
    117     if ( ! psMetadataAdd(metadata,PS_LIST_HEAD,"myItem4",PS_META_S32,"I am S32 integer",88) ) {
     124    if ( ! psMetadataAdd(metadata,PS_LIST_HEAD,"myItem4", PS_TYPE_S32, PS_META_PRIMITIVE, "I am S32 integer",88) ) {
    118125        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem did not return true when adding by index.");
    119126        return 15;
    … …  
    160167
    161168
    162     // Test H - Attempt to add item to an invalid metadata structure
    163     printNegativeTestHeader(stdout,"psMetadata","Test H - Attempt to add item to metadata w/o hash table",
     169    // Test G - Attempt to add item to an invalid metadata structure
     170    printNegativeTestHeader(stdout,"psMetadata","Test G - Attempt to add item to metadata w/o hash table",
    164171                            "Couldn't add item to invalid metadata structure.",0);
    165172    errMetadata = psMetadataAlloc();
    … …  
    175182    }
    176183    errMetadata->table = mdTable;
    177     printFooter(stdout,"psMetadata","Test H - Attempt to add item to invalid metadata w/o hash table", true);
    178 
    179     // Test J - Attempt to add item to an invalid metadata structure
    180     printNegativeTestHeader(stdout,"psMetadata","Test J - Attempt to add item to metadata w/o link list",
     184    printFooter(stdout,"psMetadata","Test G - Attempt to add item to invalid metadata w/o hash table", true);
     185
     186    // Test H - Attempt to add item to an invalid metadata structure
     187    printNegativeTestHeader(stdout,"psMetadata","Test H - Attempt to add item to metadata w/o link list",
    181188                            "Couldn't add item to invalid metadata structure.",0);
    182189    mdList = errMetadata->list;
    … …  
    191198    }
    192199    errMetadata->list = mdList;
    193     printFooter(stdout,"psMetadata","Test J - Attempt to add item to invalid metadata w/o link list", true);
    194 
    195     // Test K - Attempt to add item with a null name
    196     printNegativeTestHeader(stdout,"psMetadata","Test K - Attempt to add item with null name",
     200    printFooter(stdout,"psMetadata","Test H - Attempt to add item to invalid metadata w/o link list", true);
     201
     202    // Test I - Attempt to add item with a null name
     203    printNegativeTestHeader(stdout,"psMetadata","Test I - Attempt to add item with null name",
    197204                            "Couldn't add item with null name.",0);
    198205    errName = errItem->name;
    … …  
    203210    }
    204211    errItem->name = errName;
    205     printFooter(stdout,"psMetadata","Test K - Attempt to add item with null name", true);
    206 
    207     // Test L - Attempt to add item to an invalid metadata structure
    208     printNegativeTestHeader(stdout,"psMetadata","Test L - Attempt to add item to metadata w/o hash table",
     212    printFooter(stdout,"psMetadata","Test I - Attempt to add item with null name", true);
     213
     214    // Test J - Attempt to add item to an invalid metadata structure
     215    printNegativeTestHeader(stdout,"psMetadata","Test J - Attempt to add item to metadata w/o hash table",
    209216                            "Couldn't add item to invalid metadata structure.",0);
    210217    mdTable = errMetadata->table;
    211218    errMetadata->table = NULL;
    212     if ( psMetadataAdd(errMetadata, PS_LIST_HEAD, "errItem", PS_META_S32,"Integer",22) ) {
     219    if (psMetadataAdd(errMetadata, PS_LIST_HEAD, "errItem", PS_TYPE_S32, PS_META_PRIMITIVE, "Integer",22) ) {
    213220        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem did not return false w/ invalid metadata struct w/o hash table.");
    214221        return 24;
    215222    }
    216223    errMetadata->table = mdTable;
    217     printFooter(stdout,"psMetadata","Test L - Attempt to add item to invalid metadata w/o hash table", true);
    218 
    219     // Test G - Free psMetadata
    220     printPositiveTestHeader(stdout, "psMetadata", "Test G - Free psMetadata");
     224    printFooter(stdout,"psMetadata","Test J - Attempt to add item to invalid metadata w/o hash table", true);
     225
     226    // Test K - Free psMetadata
     227    printPositiveTestHeader(stdout, "psMetadata", "Test K - Free psMetadata");
    221228    psFree(metadata);
    222229    psFree(item1);
    … …  
    235242        printf("ERROR: Found %d bad memory blocks\n", nBad);
    236243    }
    237     printFooter(stdout, "psMetadata", "Test G - Free psMetadata", true);
     244    printFooter(stdout, "psMetadata", "Test K - Free psMetadata", true);
    238245
    239246

  • trunk/psLib/test/collections/tst_psMetadata_04.c

    r2392 r2607  
    1313*     Test G - Attempt to use null metadata
    1414*     Test H - Attempt to get non-existant metadata item
    15 *     Test I - Free psMetadata
    16 *     Test J - Attempt to look up with an invalid metadata object
     15*     Test I - Attempt to look up with an invalid metadata object
     16*     Test J - Attempt get item  with an invalid metadata object
     17*     Test K - Free psMetadata
    1718*
    1819*  @author  Ross Harman, MHPCC
    1920*
    20 *  @version $Revision: 1.8 $  $Name: not supported by cvs2svn $
    21 *  @date  $Date: 2004-11-22 20:54:50 $
     21*  @version $Revision: 1.9 $  $Name: not supported by cvs2svn $
     22*  @date  $Date: 2004-12-03 23:19:07 $
    2223*
    2324*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2930#include <string.h>
    3031
    31 static void printMetadataItem(psMetadataItem *item)
     32static void printMetadataItem(psMetadataItem *metadataItem)
    3233{
    33     printf("Key Name: %8s  ", item->name);
    34     printf("Key Type: %2d  ", item->type);
    35 
    36     switch (item->type ) {
    37     case PS_META_BOOL:
    38         printf("Key Value: %15d  ", item->data.B);
     34    printf("Key Name: %8s  ", metadataItem->name);
     35    printf("Key pType: %2d  ", metadataItem->pType);
     36    printf("Key mdType: %2d  ", metadataItem->type);
     37
     38    switch (metadataItem->type) {
     39    case PS_META_LIST:
     40        printf("Key Value: %17c", ' ');
    3941        break;
    40     case PS_META_S32:
    41         printf("Key Value: %15d  ", item->data.S32);
    42         break;
    43     case PS_META_F32:
    44         printf("Key Value: %15.3f  ", item->data.F32);
    45         break;
    46     case PS_META_F64:
    47         printf("Key Value: %15.3f  ", item->data.F64);
     42    case PS_META_PRIMITIVE:
     43        switch(metadataItem->pType) {
     44        case PS_TYPE_BOOL:
     45            printf("Key Value: %15d  ", metadataItem->data.B);
     46            break;
     47        case PS_TYPE_S32:
     48            printf("Key Value: %15d  ", metadataItem->data.S32);
     49            break;
     50        case PS_TYPE_F32:
     51            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     52            break;
     53        case PS_TYPE_F64:
     54            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     55            break;
     56        default:
     57            printf("Bad type: %d ", metadataItem->pType);
     58        }
    4859        break;
    4960    case PS_META_STR:
    50         printf("Key Value: %15s  ", (char*)item->data.V);
    51         break;
    52     case PS_META_IMG:
    53     case PS_META_JPEG:
    54     case PS_META_PNG:
    55     case PS_META_ASTROM:
    56     case PS_META_UNKNOWN:
    57         printf("Value: unknown ");
     61        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    5862        break;
    5963    default:
    60         printf("Bad type: %d ", item->type);
    61     }
    62     printf("Key Comment: %s\n", item->comment);
     64        printf("Bad type: %d ", metadataItem->type);
     65    }
     66    printf("Key Comment: %s\n", metadataItem->comment);
    6367}
    6468
    … …  
    7579    psList* tmpList = NULL;
    7680
     81
    7782    // Test A - Allocate metadata and items
    7883    printPositiveTestHeader(stdout, "psMetadata", "Test A - Allocate metadata items");
    7984    metadata = psMetadataAlloc();
    80     item1 = psMetadataItemAlloc("myItem1", PS_META_BOOL, "I am a boolean", true);
    81     item2 = psMetadataItemAlloc("myItem2", PS_META_S32, "I am a integer", 55);
    82     item3 = psMetadataItemAlloc("myItem3", PS_META_BOOL, "I am a boolean", false);
    83     item4 = psMetadataItemAlloc("myItem4", PS_META_S32, "I am a integer", 66);
     85    item1 = psMetadataItemAlloc("myItem1", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", true);
     86    item2 = psMetadataItemAlloc("myItem2", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 55);
     87    item3 = psMetadataItemAlloc("myItem3", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", false);
     88    item4 = psMetadataItemAlloc("myItem4", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 66);
    8489    printMetadataItem(item1);
    8590    printMetadataItem(item2);
    … …  
    165170    printFooter(stdout, "psMetadata", "Test H - Attempt to get non-existant metadata item", true);
    166171
    167     // Test J - Attempt to look up with an invalid metadata object
    168     printNegativeTestHeader(stdout,"psMetadata","Test J - Attemp to look up with an invalid metadata",
     172    // Test I - Attempt to look up with an invalid metadata object
     173    printNegativeTestHeader(stdout,"psMetadata","Test I - Attemp to look up with an invalid metadata",
    169174                            "Lookup item with invalid metadata object.", 0 );
    170175    tmpTable = metadata->table;
    … …  
    175180    }
    176181    metadata->table = tmpTable;
    177     printFooter(stdout, "psMetadata","Test J - Attempt to lookup an invalid metadata object.",true);
    178 
    179     // Test K - Attempt get item  with an invalid metadata object
    180     printNegativeTestHeader(stdout,"psMetadata","Test K - Attemp to get item with an invalid metadata",
     182    printFooter(stdout, "psMetadata","Test I - Attempt to lookup an invalid metadata object.",true);
     183
     184    // Test J - Attempt get item  with an invalid metadata object
     185    printNegativeTestHeader(stdout,"psMetadata","Test J - Attemp to get item with an invalid metadata",
    181186                            "Get item with invalid metadata object.", 0 );
    182187    tmpList = metadata->list;
    … …  
    187192    }
    188193    metadata->list = tmpList;
    189     printFooter(stdout, "psMetadata","Test K - Attempt to get item with  invalid metadata object.",true);
    190 
    191     // Test I - Free psMetadata
    192     printPositiveTestHeader(stdout, "psMetadata", "Test I - Free psMetadata");
     194    printFooter(stdout, "psMetadata","Test J - Attempt to get item with  invalid metadata object.",true);
     195
     196    // Test K - Free psMetadata
     197    printPositiveTestHeader(stdout, "psMetadata", "Test K - Free psMetadata");
    193198    psFree(metadata);
    194199    psFree(item1);
    … …  
    206211        return 21;
    207212    }
    208     printFooter(stdout, "psMetadata", "Test I - Free psMetadata", true);
     213    printFooter(stdout, "psMetadata", "Test K - Free psMetadata", true);
    209214
    210215

  • trunk/psLib/test/collections/tst_psMetadata_05.c

    r2527 r2607  
    2222*  @author  Ross Harman, MHPCC
    2323*
    24 *  @version $Revision: 1.12 $  $Name: not supported by cvs2svn $
    25 *  @date  $Date: 2004-11-30 01:16:43 $
     24*  @version $Revision: 1.13 $  $Name: not supported by cvs2svn $
     25*  @date  $Date: 2004-12-03 23:19:07 $
    2626*
    2727*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3333#include <string.h>
    3434
    35 static void printMetadataItem(psMetadataItem *item)
     35static void printMetadataItem(psMetadataItem *metadataItem)
    3636{
    37     printf("Key Name: %8s  ", item->name);
    38     printf("Key Type: %2d  ", item->type);
    39 
    40     switch (item->type ) {
    41     case PS_META_BOOL:
    42         printf("Key Value: %15d  ", item->data.B);
     37    printf("Key Name: %8s  ", metadataItem->name);
     38    printf("Key pType: %2d  ", metadataItem->pType);
     39    printf("Key mdType: %2d  ", metadataItem->type);
     40
     41    switch (metadataItem->type) {
     42    case PS_META_LIST:
     43        printf("Key Value: %17c", ' ');
    4344        break;
    44     case PS_META_S32:
    45         printf("Key Value: %15d  ", item->data.S32);
    46         break;
    47     case PS_META_F32:
    48         printf("Key Value: %15.3f  ", item->data.F32);
    49         break;
    50     case PS_META_F64:
    51         printf("Key Value: %15.3f  ", item->data.F64);
     45    case PS_META_PRIMITIVE:
     46        switch(metadataItem->pType) {
     47        case PS_TYPE_BOOL:
     48            printf("Key Value: %15d  ", metadataItem->data.B);
     49            break;
     50        case PS_TYPE_S32:
     51            printf("Key Value: %15d  ", metadataItem->data.S32);
     52            break;
     53        case PS_TYPE_F32:
     54            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     55            break;
     56        case PS_TYPE_F64:
     57            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     58            break;
     59        default:
     60            printf("Bad type: %d ", metadataItem->pType);
     61        }
    5262        break;
    5363    case PS_META_STR:
    54         printf("Key Value: %15s  ", (char*)item->data.V);
    55         break;
    56     case PS_META_IMG:
    57     case PS_META_JPEG:
    58     case PS_META_PNG:
    59     case PS_META_ASTROM:
    60     case PS_META_UNKNOWN:
    61         printf("Value: unknown ");
     64        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    6265        break;
    6366    default:
    64         printf("Bad type: %d ", item->type);
    65     }
    66     printf("Key Comment: %s\n", item->comment);
     67        printf("Bad type: %d ", metadataItem->type);
     68    }
     69    printf("Key Comment: %s\n", metadataItem->comment);
    6770}
    6871
    … …  
    7073psS32 main( psS32 argc, char* argv[] )
    7174{
    72     psS64 data;
    73     psF32 fpdata;
    7475    psMetadataItem *item1 = NULL;
    7576    psMetadataItem *item2 = NULL;
    … …  
    8081    psMetadataItem *item7 = NULL;
    8182    psMetadataItem *item8 = NULL;
    82     psMetadataItem *item = NULL;
    8383    psMetadata *metadata = NULL;
    8484    FILE *fd = NULL;
    85     char str[7];
    86     psList* tmpList = NULL;
    8785
    8886    // Test A - Allocate metadata and items
    8987    printPositiveTestHeader(stdout, "psMetadata", "Test A - Allocate metadata items");
    9088    metadata = psMetadataAlloc();
    91     item1 = psMetadataItemAlloc("myItem1", PS_META_BOOL, "I am a boolean", true);
    92     item2 = psMetadataItemAlloc("myItem2", PS_META_S32, "I am a integer", 55);
    93     item3 = psMetadataItemAlloc("myItem3", PS_META_BOOL, "I am a boolean", false);
    94     item4 = psMetadataItemAlloc("myItem4", PS_META_S32, "I am a integer", 66);
    95     item5 = psMetadataItemAlloc("myItem5", PS_META_F32, "I am a float", 3.14);
    96     item6 = psMetadataItemAlloc("myItem6", PS_META_F64, "I am a double", 6.28);
    97     item7 = psMetadataItemAlloc("myItem7", PS_META_STR, "I am a string", "GNIRTS");
    98     item8 = psMetadataItemAlloc("myItem8", PS_META_UNKNOWN, "I am unknown");
     89    item1 = psMetadataItemAlloc("myItem1", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", true);
     90    item2 = psMetadataItemAlloc("myItem2", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 55);
     91    item3 = psMetadataItemAlloc("myItem3", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", false);
     92    item4 = psMetadataItemAlloc("myItem4", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a integer", 66);
     93    item5 = psMetadataItemAlloc("myItem5", PS_TYPE_F32, PS_META_PRIMITIVE, "I am a float", 3.14);
     94    item6 = psMetadataItemAlloc("myItem6", PS_TYPE_F64, PS_META_PRIMITIVE,"I am a double", 6.28);
     95    item7 = psMetadataItemAlloc("myItem7", PS_TYPE_PTR, PS_META_STR, "I am a string", "GNIRTS");
     96    item8 = psMetadataItemAlloc("myItem8", PS_TYPE_PTR, PS_META_UNKNOWN, "I am unknown");
    9997    printMetadataItem(item1);
    10098    printMetadataItem(item2);
    … …  
    107105    printFooter(stdout, "psMetadata", "Test A - Allocate metadata items", true);
    108106
    109 
    110     // Test B - Set iterator at second index
    111     printPositiveTestHeader(stdout, "psMetadata", "Test B - Set iterator at second index");
    112     if ( !psMetadataSetIterator(metadata, 2)) {
    113         psError(PS_ERR_UNKNOWN,true,"Failed to set iterator");
    114         return 100;
    115     }
    116     printFooter(stdout, "psMetadata", "Test B - Set iterator at second index", true);
    117 
    118 
    119     // Test C - Get next item at index
    120     printPositiveTestHeader(stdout, "psMetadata", "Test C - Get next item at index");
    121     item = psMetadataGetNext(metadata, NULL, 2);
    122     if(item == NULL) {
    123         printf("ERROR: Item should not be null\n");
    124     } else {
    125         printf("Found item named %s\n", item->name);
    126     }
    127     printFooter(stdout, "psMetadata", "Test C - Get next item at index", true);
    128 
    129 
    130     // Test D - Get next item at index and string
    131     printPositiveTestHeader(stdout, "psMetadata", "Test D - Get next item at index and string");
    132     item = psMetadataGetNext(metadata, "myItem1", 1);
    133     if(item == NULL) {
    134         printf("ERROR: Item should not be null\n");
    135     } else {
    136         printf("Found item named %s\n", item->name);
    137     }
    138     printFooter(stdout, "psMetadata", "Test D - Get next item at index and string", true);
    139 
    140 
    141     // Test E - Get previous item at index
    142     printPositiveTestHeader(stdout, "psMetadata", "Test E - Get previous item at index");
    143     item = psMetadataGetPrevious(metadata, NULL, 1);
    144     if(item == NULL) {
    145         printf("ERROR: Item should not be null\n");
    146     } else {
    147         printf("Found item named %s\n", item->name);
    148     }
    149     if( psMetadataGetPrevious(metadata,"myItem3",1) == NULL) {
    150         psError(PS_ERR_UNKNOWN, true,"psMetadataGetPrevious did not return an item from metadata.");
    151         return 45;
    152     }
    153     tmpList = metadata->list;
    154     metadata->list = NULL;
    155     if ( psMetadataGetPrevious(metadata,NULL,1) != NULL) {
    156         psError(PS_ERR_UNKNOWN, true,"psMetadataGetPrevious did not return null for invalid metadata.");
    157         return 50;
    158     }
    159     metadata->list = tmpList;
    160     printFooter(stdout, "psMetadata", "Test E - Get previous item at index", true);
    161 
    162 
     107    /*
     108        // Test B - Set iterator at second index
     109        printPositiveTestHeader(stdout, "psMetadata", "Test B - Set iterator at second index");
     110        if (!psMetadataSetIterator(metadata, 2)) {
     111            psError(PS_ERR_UNKNOWN,true,"Failed to set iterator");
     112            return 100;
     113        }
     114        printFooter(stdout, "psMetadata", "Test B - Set iterator at second index", true);
     115     
     116     
     117        // Test C - Get next item at index
     118        printPositiveTestHeader(stdout, "psMetadata", "Test C - Get next item at index");
     119        item = psMetadataGetNext(metadata, NULL, 2);
     120        if(item == NULL) {
     121            printf("ERROR: Item should not be null\n");
     122        } else {
     123            printf("Found item named %s\n", item->name);
     124        }
     125        printFooter(stdout, "psMetadata", "Test C - Get next item at index", true);
     126     
     127     
     128        // Test D - Get next item at index and string
     129        printPositiveTestHeader(stdout, "psMetadata", "Test D - Get next item at index and string");
     130        item = psMetadataGetNext(metadata, "myItem1", 1);
     131        if(item == NULL) {
     132            printf("ERROR: Item should not be null\n");
     133        } else {
     134            printf("Found item named %s\n", item->name);
     135        }
     136        printFooter(stdout, "psMetadata", "Test D - Get next item at index and string", true);
     137     
     138     
     139        // Test E - Get previous item at index
     140        printPositiveTestHeader(stdout, "psMetadata", "Test E - Get previous item at index");
     141        item = psMetadataGetPrevious(metadata, NULL, 1);
     142        if(item == NULL) {
     143            printf("ERROR: Item should not be null\n");
     144        } else {
     145            printf("Found item named %s\n", item->name);
     146        }
     147        if( psMetadataGetPrevious(metadata,"myItem3",1) == NULL) {
     148            psError(PS_ERR_UNKNOWN, true,"psMetadataGetPrevious did not return an item from metadata.");
     149            return 45;
     150        }
     151        tmpList = metadata->list;
     152        metadata->list = NULL;
     153        if ( psMetadataGetPrevious(metadata,NULL,1) != NULL) {
     154            psError(PS_ERR_UNKNOWN, true,"psMetadataGetPrevious did not return null for invalid metadata.");
     155            return 50;
     156        }
     157        metadata->list = tmpList;
     158        printFooter(stdout, "psMetadata", "Test E - Get previous item at index", true);
     159     
     160    */
    163161    // Test F - Write metadata item to file
    164162    printPositiveTestHeader(stdout, "psMetadata", "Test F - Write metadata item to file");
    … …  
    167165        printf("ERROR: Couldn't open file for writing\n");
    168166    }
    169     psMetadataItemPrint(fd, "S32  = %ld\n", item2);
    170     psMetadataItemPrint(fd, "BOL  = %ld\n", item3);
    171     psMetadataItemPrint(fd, "F32  = %g\n", item5);
    172     psMetadataItemPrint(fd, "F64  = %g\n", item6);
    173     psMetadataItemPrint(fd, "STR  = %s\n", item7);
    174     psMetadataItemPrint(fd, "UNK  = \n", item8);
    175     printFooter(stdout, "psMetadata", "Test F - Write metadata item to file", true);
     167    psMetadataItemPrint(fd, "S32 = %ld\n", item2);
     168    psMetadataItemPrint(fd, "BOL = %ld\n", item3);
     169    psMetadataItemPrint(fd, "F32 = %g\n", item5);
     170    psMetadataItemPrint(fd, "F64 = %g\n", item6);
     171    psMetadataItemPrint(fd, "STR = %s\n", item7);
     172    psMetadataItemPrint(fd, "UNK = \n", item8);
    176173    fclose(fd);
    177174    fd = fopen("./tst_psMetadata05_OUT", "r");
    … …  
    179176        printf("ERROR: Couldn't open file for reading\n");
    180177    }
    181     fscanf(fd, "S64 = %lld\n", &data);
    182     if(data != 55) {
    183         printf("ERROR: Data in file is not as expected. Value: %lld. Should be: 55.\n", data);
    184     }
    185     fscanf(fd, "BOL = %lld\n", &data);
    186     if(data != 0) {
    187         printf("ERROR: Data in file is not as expected. Value: %lld. Should be: 0.\n", data);
    188     }
    189     fscanf(fd, "F32 = %g\n", &fpdata);
    190     if ( (fpdata <= 3.1) || (fpdata >= 3.2) ) {
    191         printf("ERROR: Data in file is not as expected. Value: %g. Should be: 3.14.\n", fpdata);
    192     }
    193     fscanf(fd, "F64 = %g\n", &fpdata);
    194     if ( (fpdata <= 6.2) || ( fpdata >= 6.3) ) {
    195         printf("ERROR: Data in file is not as expected. Value: %g. Should be: 6.28.\n", fpdata);
    196     }
    197     fscanf(fd, "STR = %s\n", str);
    198     if ( strcmp(str,"GNIRTS") != 0 ) {
    199         printf("ERROR: Data is file is not as expected. Value: %s. Should be: GNIRTS.\n", str);
    200     }
     178
     179    char line[256];
     180    char truth1[] = "S32 = 55";
     181    fgets(line, 256, fd);
     182    if(strncmp(line, truth1, 8)) {
     183        printf("ERROR: Data in file is not as expected. Value: %s. Should be: %s\n", line, truth1);
     184    }
     185
     186    char truth2[] = "BOL = 0";
     187    fgets(line, 256, fd);
     188    if(strncmp(line, truth2, 7)) {
     189        printf("ERROR: Data in file is not as expected. Value: %s. Should be: %s\n", line, truth2);
     190    }
     191
     192    char truth3[] = "F32 = 3.14";
     193    fgets(line, 256, fd);
     194    if(strncmp(line, truth3, 10)) {
     195        printf("ERROR: Data in file is not as expected. Value: %s. Should be: %s\n", line, truth3);
     196    }
     197
     198    char truth4[] = "F64 = 6.28";
     199    fgets(line, 256, fd);
     200    if(strncmp(line, truth4, 10)) {
     201        printf("ERROR: Data in file is not as expected. Value: %s. Should be: %s\n", line, truth4);
     202    }
     203
     204    char truth5[] = "STR = GNIRTS";
     205    fgets(line, 256, fd);
     206    if(strncmp(line, truth5, 12)) {
     207        printf("ERROR: Data in file is not as expected. Value: %s. Should be: %s\n", line, truth5);
     208    }
     209
    201210    fclose(fd);
    202 
    203     // Test G - Attempt to use null metadata with setIterator
    204     printNegativeTestHeader(stdout,"psMetadata", "Test G - Attempt to use null metadata with setIterator",
    205                             "Null metadata collection not allowed", 0);
    206     if( psMetadataSetIterator(NULL, 0)) {
    207         psError(PS_ERR_UNKNOWN,true,"Set iterator did not detect invalid parameter.");
    208         return 101;
    209     }
    210     tmpList = metadata->list;
    211     metadata->list = NULL;
    212     if( psMetadataSetIterator(metadata,0)) {
    213         psError(PS_ERR_UNKNOWN,true,"Set iterator did not detect null list.");
    214         return 102;
    215     }
    216     metadata->list = tmpList;
    217     printFooter(stdout, "psMetadata", "Test G - Attempt to use null metadata with setIterator", true);
    218 
    219 
    220     // Test H - Attempt to use null metadata with getNext
    221     printNegativeTestHeader(stdout,"psMetadata", "Test H - Attempt to use null metadata with getNext",
    222                             "Null metadata collection not allowed", 0);
    223     if( psMetadataGetNext(NULL, "myItem2", 0) != NULL ) {
    224         psError(PS_ERR_UNKNOWN, true,"psMetadataGetNext did not return null for null metadata.");
    225         return 40;
    226     }
    227     tmpList = metadata->list;
    228     metadata->list = NULL;
    229     if ( psMetadataGetNext(metadata, "myItem2", 0) != NULL ) {
    230         psError(PS_ERR_UNKNOWN, true,"psMetadataGetNext did not return null for invalid metadata.");
    231         return 41;
    232     }
    233     metadata->list = tmpList;
    234 
    235     printFooter(stdout, "psMetadata", "Test H - Attempt to use null metadata with getNext", true);
    236 
    237 
    238     // Test I - Attempt to use null metadata with getPrevious
    239     printNegativeTestHeader(stdout,"psMetadata", "Test I - Attempt to use null metadata with getPrevious",
    240                             "Null metadata collection not allowed", 0);
    241     psMetadataGetPrevious(NULL, "myItem2", 0);
    242     printFooter(stdout, "psMetadata", "Test I - Attempt to use null metadata with getPrevious", true);
    243 
    244 
     211    printFooter(stdout, "psMetadata", "Test F - Write metadata item to file", true);
     212    /*
     213        // Test G - Attempt to use null metadata with setIterator
     214        printNegativeTestHeader(stdout,"psMetadata", "Test G - Attempt to use null metadata with setIterator",
     215                                "Null metadata collection not allowed", 0);
     216        if( psMetadataSetIterator(NULL, 0)) {
     217            psError(PS_ERR_UNKNOWN,true,"Set iterator did not detect invalid parameter.");
     218            return 101;
     219        }
     220        tmpList = metadata->list;
     221        metadata->list = NULL;
     222        if( psMetadataSetIterator(metadata,0)) {
     223            psError(PS_ERR_UNKNOWN,true,"Set iterator did not detect null list.");
     224            return 102;
     225        }
     226        metadata->list = tmpList;
     227        printFooter(stdout, "psMetadata", "Test G - Attempt to use null metadata with setIterator", true);
     228     
     229     
     230        // Test H - Attempt to use null metadata with getNext
     231        printNegativeTestHeader(stdout,"psMetadata", "Test H - Attempt to use null metadata with getNext",
     232                                "Null metadata collection not allowed", 0);
     233        if( psMetadataGetNext(NULL, "myItem2", 0) != NULL ) {
     234            psError(PS_ERR_UNKNOWN, true,"psMetadataGetNext did not return null for null metadata.");
     235            return 40;
     236        }
     237        tmpList = metadata->list;
     238        metadata->list = NULL;
     239        if ( psMetadataGetNext(metadata, "myItem2", 0) != NULL ) {
     240            psError(PS_ERR_UNKNOWN, true,"psMetadataGetNext did not return null for invalid metadata.");
     241            return 41;
     242        }
     243        metadata->list = tmpList;
     244     
     245        printFooter(stdout, "psMetadata", "Test H - Attempt to use null metadata with getNext", true);
     246     
     247     
     248        // Test I - Attempt to use null metadata with getPrevious
     249        printNegativeTestHeader(stdout,"psMetadata", "Test I - Attempt to use null metadata with getPrevious",
     250                                "Null metadata collection not allowed", 0);
     251        psMetadataGetPrevious(NULL, "myItem2", 0);
     252        printFooter(stdout, "psMetadata", "Test I - Attempt to use null metadata with getPrevious", true);
     253     
     254    */
    245255    // Test J - Attempt to use null file with itemPrint
    246256    printNegativeTestHeader(stdout,"psMetadata", "Test J - Attempt to use null file with itemPrint",

  • trunk/psLib/test/collections/tst_psMetadata_06.c

    r2392 r2607  
    1313*  @author  Ross Harman, MHPCC
    1414*
    15 *  @version $Revision: 1.6 $  $Name: not supported by cvs2svn $
    16 *  @date  $Date: 2004-11-22 20:54:50 $
     15*  @version $Revision: 1.7 $  $Name: not supported by cvs2svn $
     16*  @date  $Date: 2004-12-03 23:19:07 $
    1717*
    1818*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include <string.h>
    2525
    26 static void printMetadataItem(psMetadataItem *item)
     26static void printMetadataItem(psMetadataItem *metadataItem)
    2727{
    28     printf("Key Name: %8s  ", item->name);
    29     printf("Key Type: %2d  ", item->type);
     28    printf("Key Name: %8s  ", metadataItem->name);
     29    printf("Key pType: %2d  ", metadataItem->pType);
     30    printf("Key mdType: %2d  ", metadataItem->type);
    3031
    31     switch (item->type ) {
    32     case PS_META_BOOL:
    33         printf("Key Value: %15d  ", item->data.B);
     32    switch (metadataItem->type) {
     33    case PS_META_LIST:
     34        printf("Key Value: %17c", ' ');
    3435        break;
    35     case PS_META_S32:
    36         printf("Key Value: %15d  ", item->data.S32);
    37         break;
    38     case PS_META_F32:
    39         printf("Key Value: %15.3f  ", item->data.F32);
    40         break;
    41     case PS_META_F64:
    42         printf("Key Value: %15.3f  ", item->data.F64);
     36    case PS_META_PRIMITIVE:
     37        switch(metadataItem->pType) {
     38        case PS_TYPE_BOOL:
     39            printf("Key Value: %15d  ", metadataItem->data.B);
     40            break;
     41        case PS_TYPE_S32:
     42            printf("Key Value: %15d  ", metadataItem->data.S32);
     43            break;
     44        case PS_TYPE_F32:
     45            printf("Key Value: %15.3f  ", metadataItem->data.F32);
     46            break;
     47        case PS_TYPE_F64:
     48            printf("Key Value: %15.3f  ", metadataItem->data.F64);
     49            break;
     50        default:
     51            printf("Bad type: %d ", metadataItem->pType);
     52        }
    4353        break;
    4454    case PS_META_STR:
    45         printf("Key Value: %15s  ", (char*)item->data.V);
    46         break;
    47     case PS_META_IMG:
    48     case PS_META_JPEG:
    49     case PS_META_PNG:
    50     case PS_META_ASTROM:
    51     case PS_META_UNKNOWN:
    52         printf("Value: unknown ");
     55        printf("Key Value: %15s  ", (char*)metadataItem->data.V);
    5356        break;
    5457    default:
    55         printf("Bad type: %d ", item->type);
     58        printf("Bad type: %d ", metadataItem->type);
    5659    }
    57     printf("Key Comment: %s\n", item->comment);
     60    printf("Key Comment: %s\n", metadataItem->comment);
    5861}
    5962
    … …  
    7174    // Test A - Allocate metadata and items
    7275    printPositiveTestHeader(stdout, "psMetadata", "Test A - Allocate metadata and items");
    73     item1a = psMetadataItemAlloc("myItem1", PS_META_BOOL, "I am a boolean", true);
    74     item1b = psMetadataItemAlloc("myItem1", PS_META_S32, "I am a signed integer", 111);
    75     item1c = psMetadataItemAlloc("myItem1", PS_META_S32, "I am a signed integer", 222);
    76     item2a = psMetadataItemAlloc("myItem2", PS_META_S32, "I am a signed integer", 333);
    77     item2b = psMetadataItemAlloc("myItem2", PS_META_ITEM_SET, "I am a folder node", NULL);
     76    item1a = psMetadataItemAlloc("myItem1", PS_TYPE_BOOL, PS_META_PRIMITIVE, "I am a boolean", true);
     77    item1b = psMetadataItemAlloc("myItem1", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a signed integer", 111);
     78    item1c = psMetadataItemAlloc("myItem1", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a signed integer", 222);
     79    item2a = psMetadataItemAlloc("myItem2", PS_TYPE_S32, PS_META_PRIMITIVE, "I am a signed integer", 333);
     80    item2b = psMetadataItemAlloc("myItem2", PS_TYPE_PTR, PS_META_LIST, "I am a folder node", NULL);
    7881    metadata = psMetadataAlloc();
    7982    printMetadataItem(item1a);
    … …  
    8790    // Test B - Add leaf node on top of existing leaf node
    8891    printPositiveTestHeader(stdout, "psMetadata", "Test B - Add leaf node on top of existing leaf node");
    89     if( ! psMetadataAddItem(metadata, item1a, PS_LIST_HEAD) ) {
     92    if(!psMetadataAddItem(metadata, item1a, PS_LIST_HEAD)) {
    9093        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem returned false for adding a node top.");
    9194        return 20;
    9295    }
    93     if ( ! psMetadataAddItem(metadata, item1b, PS_LIST_HEAD) ) {
     96    if (!psMetadataAddItem(metadata, item1b, PS_LIST_HEAD)) {
    9497        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem returned false for adding a node top.");
    9598        return 21;
    … …  
    101104    // Test C - Add leaf node to existing folder node
    102105    printPositiveTestHeader(stdout, "psMetadata", "Test C - Add leaf node to existing folder node");
    103     if ( ! psMetadataAddItem(metadata, item1c, PS_LIST_HEAD) ) {
     106    if (!psMetadataAddItem(metadata, item1c, PS_LIST_HEAD)) {
    104107        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem return false for adding a not to existing node.");
    105108        return 22;
    … …  
    110113    // Test D - Add folder node on top of existing leaf node
    111114    printPositiveTestHeader(stdout, "psMetadata", "Test D - Add folder node on top of existing leaf node");
    112     if ( ! psMetadataAddItem(metadata, item2a, PS_LIST_HEAD) ) {
     115    if (!psMetadataAddItem(metadata, item2a, PS_LIST_HEAD)) {
    113116        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem returned false for adding a node to existing leaf node.");
    114117        return 23;
    115118    }
    116     if ( ! psMetadataAddItem(metadata, item2b, PS_LIST_HEAD) ) {
     119    if (!psMetadataAddItem(metadata, item2b, PS_LIST_HEAD)) {
    117120        psError(PS_ERR_UNKNOWN, true,"psMetadataAddItem returned false for adding a nod to existing leaf node.");
    118121        return 24;
Note: See TracChangeset for help on using the changeset viewer.