IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jul 17, 2006, 12:41:38 PM (20 years ago)
Author:
Paul Price
Message:

Fixing use of regex in psMetadataIterator; see bug 779. Adding new tests for psListIterator and psMetadataIterator.

Location:
trunk/psLib/test/types
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/types

    • Property svn:ignore

      •  

        old new  
        4242tst_psArguments
        4343mdcfgwrt.verified
         44tap_psListIterator
         45tap_psMetadataIterator

  • trunk/psLib/test/types/.cvsignore

    r6801 r7918  
    4343mdcfgwrt.verified
    4444
     45tap_psListIterator
     46tap_psMetadataIterator

  • trunk/psLib/test/types/Makefile.am

    r7916 r7918  
    2727        tst_psPixels \
    2828        tst_psArguments \
    29         tap_psMetadataIterator
     29        tap_psMetadataIterator \
     30        tap_psListIterator
    3031
    3132
    … …  
    5354tap_psMetadataIterator_CPPFLAGS   = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src
    5455tap_psMetadataIterator_LDFLAGS    = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la
     56
     57tap_psListIterator_CPPFLAGS   = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src
     58tap_psListIterator_LDFLAGS    = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la
    5559
    5660check_DATA = \

  • trunk/psLib/test/types/tap_psMetadataIterator.c

    r7916 r7918  
    1212#define COMMENT2 "This is a    "
    1313#define FLAG2 PS_META_DUPLICATE_OK
    14 #define VALUE2 ""
     14#define VALUE2 "   comment."
    1515
    1616#define NAME3 "FILENAME"
    1717#define COMMENT3 "File name"
    1818#define FLAG3 0
    19 #define VALUE3 "abcdefg123456.fits"
     19#define VALUE3 "abcdef123456.fits"
    2020
    2121#define NAME4 "COMMENT"
    22 #define COMMENT4 "   comment   "
     22#define COMMENT4 "   this IS a   "
    2323#define FLAG4 PS_META_DUPLICATE_OK
    24 #define VALUE4 ""
     24#define VALUE4 "comment    too!"
    2525
    2626#define NAME5 "DATE-OBS"
    … …  
    3030
    3131#define NAME6 "COMMENT"
    32 #define COMMENT6 "    block"
     32#define COMMENT6 "    another"
    3333#define FLAG6 PS_META_DUPLICATE_OK
    34 #define VALUE6 ""
     34#define VALUE6 "comment     "
    3535
    3636#define NAME7 "COMMENT"
    3737#define COMMENT7 "This is another comment"
    3838#define FLAG7 PS_META_DUPLICATE_OK
    39 #define VALUE7 ""
     39#define VALUE7 "Hello world"
    4040
    4141#define MULTI_NAME "COMMENT"
    … …  
    4848#define MULTI_COMMENT3 COMMENT6
    4949#define MULTI_COMMENT4 COMMENT7
    50 
    51 psMetadata *mdGenerate(void)
     50#define MULTI_VALUE1 VALUE2
     51#define MULTI_VALUE2 VALUE4
     52#define MULTI_VALUE3 VALUE6
     53#define MULTI_VALUE4 VALUE7
     54
     55// Generate a dummy metadata
     56static psMetadata *mdGenerate(void)
    5257{
    5358    psMetadata *md = psMetadataAlloc();
    … …  
    6570}
    6671
    67 #define TEST_ITERATION(NAME, COMMENT, VALUE) \
    68 item = psMetadataGetAndIncrement(iter); \
    69 ok(item, "item = %x", item); \
    70 skip_start(!item, 3, "Skipping 3 tests because psMetadataGetAndIncrement failed"); \
    71 ok(strcmp(item->name, NAME) == 0, "item->name = %s", item->name); \
    72 ok(strcmp(item->comment, COMMENT) == 0, "item->comment = %s", item->comment); \
    73 ok(strcmp(item->data.V, VALUE) == 0, "item->data.V = %s", item->data.V); \
    74 skip_end();
     72// Function to perform iteration
     73typedef psMetadataItem *(*iterFunc)(psMetadataIterator *iter);
     74
     75
     76// Test the iteration by iterating once and checking the name, comment, and data
     77static void testIteration(iterFunc function, // Function to use to iterate
     78                          psMetadataIterator *iterator, // The iterator
     79                          const char *name, // Name of the item
     80                          const char *comment, // Comment for the item
     81                          const char *value // Value for the item
     82                         )
     83{
     84    psMetadataItem *item = function(iterator);
     85    ok(item, "item = %x", item);
     86    skip_start(!item, 4, "Skipping 4 tests because iteration failed");
     87    ok(strcmp(item->name, name) == 0, "item->name = %s", item->name);
     88    ok(strcmp(item->comment, comment) == 0, "item->comment = %s", item->comment);
     89    ok(item->type == PS_DATA_STRING, "item->type = %x", item->type);
     90    skip_start(item->type != PS_DATA_STRING, 1, "Skipping 1 test because the item has incorrect type");
     91    ok(strcmp(item->data.V, value) == 0, "item->data.V = %s", item->data.V);
     92    skip_end();
     93    skip_end();
     94
     95    return;
     96}
    7597
    7698
    7799int main (void)
    78100{
    79     plan_tests(42);
     101    plan_tests(242);
    80102
    81103    diag("psMetadataIterator tests");
    82104
    83     // No regular expressions
    84     {
     105    {
     106        diag("No regular expressions, forwards");
    85107        psMetadata *md = mdGenerate();
    86108        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    87109        ok(iter, "iter = %x", iter);
    88         skip_start(!iter, 28, "Skipping 28 tests because psMetadataIteratorAlloc failed");
    89         psMetadataItem *item;
    90 
    91         TEST_ITERATION(NAME1, COMMENT1, VALUE1);
    92         TEST_ITERATION(NAME2, COMMENT2, VALUE2);
    93         TEST_ITERATION(NAME3, COMMENT3, VALUE3);
    94         TEST_ITERATION(NAME4, COMMENT4, VALUE4);
    95         TEST_ITERATION(NAME5, COMMENT5, VALUE5);
    96         TEST_ITERATION(NAME6, COMMENT6, VALUE6);
    97         TEST_ITERATION(NAME7, COMMENT7, VALUE7);
    98 
    99         skip_end();
    100         psFree(iter);
    101         psFree(md);
    102     }
    103 
    104     // With regular expressions
    105     {
     110        skip_start(!iter, 35, "Skipping 35 tests because psMetadataIteratorAlloc failed");
     111
     112        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME1, COMMENT1, VALUE1);
     113        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME2, COMMENT2, VALUE2);
     114        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME3, COMMENT3, VALUE3);
     115        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME4, COMMENT4, VALUE4);
     116        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME5, COMMENT5, VALUE5);
     117        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME6, COMMENT6, VALUE6);
     118        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME7, COMMENT7, VALUE7);
     119
     120        skip_end();
     121        psFree(iter);
     122        psFree(md);
     123    }
     124
     125    {
     126        diag("No regular expressions, backwards");
     127        psMetadata *md = mdGenerate();
     128        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_TAIL, NULL);
     129        ok(iter, "iter = %x", iter);
     130        skip_start(!iter, 35, "Skipping 35 tests because psMetadataIteratorAlloc failed");
     131
     132        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME7, COMMENT7, VALUE7);
     133        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME6, COMMENT6, VALUE6);
     134        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME5, COMMENT5, VALUE5);
     135        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME4, COMMENT4, VALUE4);
     136        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME3, COMMENT3, VALUE3);
     137        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME2, COMMENT2, VALUE2);
     138        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME1, COMMENT1, VALUE1);
     139
     140        skip_end();
     141        psFree(iter);
     142        psFree(md);
     143    }
     144
     145    {
     146        diag("No regular expressions, jumping in halfway through (using allocator), forwards");
     147        psMetadata *md = mdGenerate();
     148        psMetadataIterator *iter = psMetadataIteratorAlloc(md, 3, NULL);
     149        ok(iter, "iter = %x", iter);
     150        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     151
     152        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME4, COMMENT4, VALUE4);
     153        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME5, COMMENT5, VALUE5);
     154        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME6, COMMENT6, VALUE6);
     155        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME7, COMMENT7, VALUE7);
     156
     157        skip_end();
     158        psFree(iter);
     159        psFree(md);
     160    }
     161
     162    {
     163        diag("No regular expressions, jumping in halfway through (using allocator), backwards");
     164        psMetadata *md = mdGenerate();
     165        psMetadataIterator *iter = psMetadataIteratorAlloc(md, -4, NULL);
     166        ok(iter, "iter = %x", iter);
     167        skip_start(!iter, 15, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     168
     169        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME4, COMMENT4, VALUE4);
     170        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME3, COMMENT3, VALUE3);
     171        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME2, COMMENT2, VALUE2);
     172        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME1, COMMENT1, VALUE1);
     173
     174        skip_end();
     175        psFree(iter);
     176        psFree(md);
     177    }
     178
     179    {
     180        diag("No regular expressions, jumping in halfway through (using set), forwards");
     181        psMetadata *md = mdGenerate();
     182        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
     183        ok(iter, "iter = %x", iter);
     184        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     185        psMetadataIteratorSet(iter, 3);
     186
     187        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME4, COMMENT4, VALUE4);
     188        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME5, COMMENT5, VALUE5);
     189        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME6, COMMENT6, VALUE6);
     190        testIteration((iterFunc)psMetadataGetAndIncrement, iter, NAME7, COMMENT7, VALUE7);
     191
     192        skip_end();
     193        psFree(iter);
     194        psFree(md);
     195    }
     196
     197    {
     198        diag("No regular expressions, jumping in halfway through (using set), backwards");
     199        psMetadata *md = mdGenerate();
     200        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
     201        ok(iter, "iter = %x", iter);
     202        skip_start(!iter, 15, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     203        psMetadataIteratorSet(iter, -4);
     204
     205        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME4, COMMENT4, VALUE4);
     206        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME3, COMMENT3, VALUE3);
     207        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME2, COMMENT2, VALUE2);
     208        testIteration((iterFunc)psMetadataGetAndDecrement, iter, NAME1, COMMENT1, VALUE1);
     209
     210        skip_end();
     211        psFree(iter);
     212        psFree(md);
     213    }
     214
     215    {
     216        diag("With regular expressions, forwards");
    106217        psMetadata *md = mdGenerate();
    107218        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$");
    108219        ok(iter, "iter = %x", iter);
    109         skip_start(!iter, 12, "Skipping 12 tests because psMetadataIteratorAlloc failed");
    110         psMetadataItem *item;
    111 
    112         TEST_ITERATION(MULTI_NAME1, MULTI_COMMENT1, "");
    113         TEST_ITERATION(MULTI_NAME2, MULTI_COMMENT2, "");
    114         TEST_ITERATION(MULTI_NAME3, MULTI_COMMENT3, "");
    115         TEST_ITERATION(MULTI_NAME4, MULTI_COMMENT4, "");
    116 
    117         skip_end();
    118         psFree(iter);
    119         psFree(md);
    120     }
     220        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     221
     222        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME1, MULTI_COMMENT1, MULTI_VALUE1);
     223        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME2, MULTI_COMMENT2, MULTI_VALUE2);
     224        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME3, MULTI_COMMENT3, MULTI_VALUE3);
     225        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME4, MULTI_COMMENT4, MULTI_VALUE4);
     226
     227        skip_end();
     228        psFree(iter);
     229        psFree(md);
     230    }
     231
     232    {
     233        diag("With regular expressions, backwards");
     234        psMetadata *md = mdGenerate();
     235        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_TAIL, "^" MULTI_NAME "$");
     236        ok(iter, "iter = %x", iter);
     237        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     238
     239        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME4, MULTI_COMMENT4, MULTI_VALUE4);
     240        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME3, MULTI_COMMENT3, MULTI_VALUE3);
     241        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME2, MULTI_COMMENT2, MULTI_VALUE2);
     242        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME1, MULTI_COMMENT1, MULTI_VALUE1);
     243
     244        skip_end();
     245        psFree(iter);
     246        psFree(md);
     247    }
     248
     249    {
     250        diag("With regular expressions, jumping in halfway through (using allocator), forwards");
     251        psMetadata *md = mdGenerate();
     252        psMetadataIterator *iter = psMetadataIteratorAlloc(md, 2, "^" MULTI_NAME "$");
     253        ok(iter, "iter = %x", iter);
     254        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     255
     256        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME3, MULTI_COMMENT3, MULTI_VALUE3);
     257        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME4, MULTI_COMMENT4, MULTI_VALUE4);
     258
     259        skip_end();
     260        psFree(iter);
     261        psFree(md);
     262    }
     263
     264    {
     265        diag("With regular expressions, jumping in halfway through (using allocator), backwards");
     266        psMetadata *md = mdGenerate();
     267        psMetadataIterator *iter = psMetadataIteratorAlloc(md, -3, "^" MULTI_NAME "$");
     268        ok(iter, "iter = %x", iter);
     269        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     270
     271        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME2, MULTI_COMMENT2, MULTI_VALUE2);
     272        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME1, MULTI_COMMENT1, MULTI_VALUE1);
     273
     274        skip_end();
     275        psFree(iter);
     276        psFree(md);
     277    }
     278
     279    {
     280        diag("With regular expressions, jumping in halfway through (using set), forwards");
     281        psMetadata *md = mdGenerate();
     282        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$");
     283        ok(iter, "iter = %x", iter);
     284        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     285        psMetadataIteratorSet(iter, 2);
     286
     287        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME3, MULTI_COMMENT3, MULTI_VALUE3);
     288        testIteration((iterFunc)psMetadataGetAndIncrement, iter, MULTI_NAME4, MULTI_COMMENT4, MULTI_VALUE4);
     289
     290        skip_end();
     291        psFree(iter);
     292        psFree(md);
     293    }
     294
     295    {
     296        diag("With regular expressions, jumping in halfway through (using set), backwards");
     297        psMetadata *md = mdGenerate();
     298        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$");
     299        ok(iter, "iter = %x", iter);
     300        skip_start(!iter, 20, "Skipping 20 tests because psMetadataIteratorAlloc failed");
     301        psMetadataIteratorSet(iter, -3);
     302
     303        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME2, MULTI_COMMENT2, MULTI_VALUE2);
     304        testIteration((iterFunc)psMetadataGetAndDecrement, iter, MULTI_NAME1, MULTI_COMMENT1, MULTI_VALUE1);
     305
     306        skip_end();
     307        psFree(iter);
     308        psFree(md);
     309    }
     310
    121311
    122312    return exit_status();
Note: See TracChangeset for help on using the changeset viewer.