IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 7918


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
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/types/psMetadata.c

    r7914 r7918  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.117 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-07-15 02:57:12 $
     14 *  @version $Revision: 1.118 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-07-17 22:41:38 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    919919
    920920    psMetadataIterator* newIter = psAlloc(sizeof(psMetadataIterator));
    921     newIter->regex = NULL;
    922     newIter->iter = NULL;
    923 
    924     // Set deallocator
    925921    psMemSetDeallocator(newIter, (psFreeFunc) metadataIteratorFree);
    926922
    … …  
    929925    if (regex) {
    930926        newIter->regex = psAlloc(sizeof(regex_t));
    931         int regRtn = regcomp(newIter->regex,regex,0);
     927        int regRtn = regcomp(newIter->regex, regex, 0);
    932928        if (regRtn != 0) {
    933929            char errMsg[256];
    934930            regerror(regRtn, newIter->regex, errMsg, 256);
    935             regfree(newIter->regex);
    936931            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    937932                    PS_ERRORTEXT_psMetadata_REGEX_INVALID,
    … …  
    940935            return NULL;
    941936        }
     937        if (!psMetadataIteratorSet(newIter, location)) {
     938            psError(PS_ERR_UNKNOWN, false, "Unable to set location=%d for metadata iterator.\n", location);
     939            psFree(newIter);
     940            return NULL;
     941        }
     942    } else {
     943        newIter->regex = NULL;
    942944    }
    943945
    … …  
    948950                           long location)
    949951{
    950     int match;
    951     psMetadataItem* cursor;
    952 
    953     PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    954 
    955     psListIterator* iter = iterator->iter;
    956     PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
    957 
    958     regex_t* regex = iterator->regex;
     952    PS_ASSERT_PTR_NON_NULL(iterator, NULL);
     953    psListIterator *listIter = iterator->iter;
     954    PS_ASSERT_PTR_NON_NULL(listIter, NULL);
     955
     956    regex_t *regex = iterator->regex;
    959957
    960958    // handle trivial case where no regex subsetting is required.
    961959    if (regex == NULL) {
    962         return psListIteratorSet(iter,location);
    963     }
    964 
     960        return psListIteratorSet(listIter, location);
     961    }
     962
     963    // If there's a regex, then we need to count into the list.
     964    // We count ONLY those entries that match the regex
     965
     966    // Here we count in from the tail
    965967    if (location < 0) {
    966         // match from the tail
    967         match = 0;
    968         psListIteratorSet(iter,PS_LIST_TAIL);
    969         while ( (cursor=(psMetadataItem*)iter->cursor) != NULL) {
    970             if (regexec(regex, cursor->name, 0, NULL, 0) == 0) {
     968        psListIteratorSet(listIter, PS_LIST_TAIL);
     969        psMetadataItem *item;           // Item from iteration
     970        int match = 0;                  // Match number
     971        while (listIter->cursor && (item = listIter->cursor->data)) {
     972            if (regexec(regex, item->name, 0, NULL, 0) == 0) {
    971973                // this key is a match
    972974                match--;
    … …  
    975977                }
    976978            }
    977             (void)psListGetAndDecrement(iter);
     979            (void)psListGetAndDecrement(listIter);
    978980        }
    979981        return (match == location);
    980982    }
    981983
    982     // find the n-th match from the head
    983     match = -1;
    984     psListIteratorSet(iter,PS_LIST_HEAD);
    985     while ( (cursor=(psMetadataItem*)iter->cursor) != NULL) {
    986         if (regexec(regex, cursor->name, 0, NULL, 0) == 0) {
     984    // Here we count in from the head
     985    psListIteratorSet(listIter, PS_LIST_HEAD);
     986    psMetadataItem *item;               // Item from iteration
     987    int match = -1;                     // Match number
     988    while (listIter->cursor && (item = listIter->cursor->data)) {
     989        if (regexec(regex, item->name, 0, NULL, 0) == 0) {
    987990            // this key is a match
    988991            match++;
    … …  
    991994            }
    992995        }
    993         (void)psListGetAndIncrement(iter);
     996        (void)psListGetAndIncrement(listIter);
    994997    }
    995998    return (match == location);
    … …  
    9981001psMetadataItem* psMetadataGetAndIncrement(psMetadataIterator* iterator)
    9991002{
    1000     psMetadataItem* oldValue;
    1001 
    10021003    PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    1003 
    1004     psListIterator* iter = iterator->iter;
    1005     PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
     1004    psListIterator* listIter = iterator->iter;
     1005    PS_ASSERT_PTR_NON_NULL(listIter,NULL);
    10061006
    10071007    regex_t* regex = iterator->regex;
    … …  
    10091009    // handle trivial case where no regex subsetting is required.
    10101010    if (regex == NULL) {
    1011         return (psMetadataItem*)psListGetAndIncrement(iter);
    1012     }
    1013 
    1014     oldValue = (psMetadataItem*)iter->cursor;
    1015 
    1016     while (psListGetAndIncrement(iter) != NULL) {
    1017         if (iter->cursor != NULL &&
    1018                 regexec(regex, ((psMetadataItem*)iter->cursor->data)->name, 0, NULL, 0) == 0) {
     1011        return (psMetadataItem*)psListGetAndIncrement(listIter);
     1012    }
     1013
     1014    // Iterate until we find something matching the regex
     1015    psMetadataItem *newItem;            // New MD item from iteration
     1016    while ((newItem = psListGetAndIncrement(listIter))) {
     1017        if (regexec(regex, newItem->name, 0, NULL, 0) == 0) {
    10191018            // this key is a match
    10201019            break;
    10211020        }
    10221021    }
    1023     return oldValue;
     1022    return newItem;
    10241023}
    10251024
    10261025psMetadataItem* psMetadataGetAndDecrement(psMetadataIterator* iterator)
    10271026{
    1028     psMetadataItem* oldValue;
    1029 
    1030     PS_ASSERT_PTR_NON_NULL(iterator,NULL);
    1031 
    1032     psListIterator* iter = iterator->iter;
    1033     PS_ASSERT_PTR_NON_NULL(iterator->iter,NULL);
     1027    PS_ASSERT_PTR_NON_NULL(iterator, NULL);
     1028    psListIterator* listIter = iterator->iter;
     1029    PS_ASSERT_PTR_NON_NULL(listIter, NULL);
    10341030
    10351031    regex_t* regex = iterator->regex;
    … …  
    10371033    // handle trivial case where no regex subsetting is required.
    10381034    if (regex == NULL) {
    1039         return (psMetadataItem*)psListGetAndDecrement(iter);
    1040     }
    1041 
    1042     oldValue = (psMetadataItem*)iter->cursor;
    1043 
    1044     while (psListGetAndDecrement(iter) != NULL) {
    1045         if (iter->cursor != NULL &&
    1046                 regexec(regex, ((psMetadataItem*)iter->cursor)->name, 0, NULL, 0) == 0) {
     1035        return (psMetadataItem*)psListGetAndDecrement(listIter);
     1036    }
     1037
     1038    // Iterate until we find something matching the regex
     1039    psMetadataItem *newItem;            // New MD item from iteration
     1040    while ((newItem = psListGetAndDecrement(listIter))) {
     1041        if (regexec(regex, newItem->name, 0, NULL, 0) == 0) {
    10471042            // this key is a match
    10481043            break;
    10491044        }
    10501045    }
    1051     return oldValue;
     1046    return newItem;
    10521047}
    10531048

  • 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.