Changeset 7359


Ignore:
Timestamp:
Dec 12, 2008, 2:12:17 AM (10 years ago)
Author:
charles
Message:

(trunk libT) #1559 (partial): add tr_bencDictMerge() + unit tests. patch by KyleK and charles_

Location:
trunk/libtransmission
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/bencode-test.c

    r6842 r7359  
    362362}
    363363
     364static int
     365testMerge( void )
     366{
     367    tr_benc dest, src;
     368    int64_t i;
     369    const char * s;
     370
     371    /* initial dictionary (default values)  */
     372    tr_bencInitDict( &dest, 10 );
     373    tr_bencDictAddInt( &dest, "i1", 1 );
     374    tr_bencDictAddInt( &dest, "i2", 2 );
     375    tr_bencDictAddInt( &dest, "i4", -35 ); /* remains untouched */
     376    tr_bencDictAddStr( &dest, "s5", "abc" );
     377    tr_bencDictAddStr( &dest, "s6", "def" );
     378    tr_bencDictAddStr( &dest, "s7", "127.0.0.1" ); /* remains untouched */
     379
     380    /* new dictionary, will overwrite items in dest  */
     381    tr_bencInitDict( &src, 10 );
     382    tr_bencDictAddInt( &src, "i1", 1 );     /* same value */
     383    tr_bencDictAddInt( &src, "i2", 4 );     /* new value */
     384    tr_bencDictAddInt( &src, "i3", 3 );     /* new key:value */
     385    tr_bencDictAddStr( &src, "s5", "abc" ); /* same value */
     386    tr_bencDictAddStr( &src, "s6", "xyz" ); /* new value */
     387    tr_bencDictAddStr( &src, "s8", "ghi" ); /* new key:value */
     388
     389    tr_bencMergeDicts( &dest, /*const*/ &src );
     390
     391    check( tr_bencDictFindInt( &dest, "i1", &i ));
     392    check( i == 1);
     393    check( tr_bencDictFindInt( &dest, "i2", &i ));
     394    check( i == 4);
     395    check( tr_bencDictFindInt( &dest, "i3", &i ));
     396    check( i == 3);
     397    check( tr_bencDictFindInt( &dest, "i4", &i ));
     398    check( i == -35);
     399    check( tr_bencDictFindStr( &dest, "s5", &s ));
     400    check( strcmp( "abc", s ) == 0 );
     401    check( tr_bencDictFindStr( &dest, "s6", &s ));
     402    check( strcmp( "xyz", s ) == 0 );
     403    check( tr_bencDictFindStr( &dest, "s7", &s ));
     404    check( strcmp( "127.0.0.1", s ) == 0 );
     405    check( tr_bencDictFindStr( &dest, "s8", &s ));
     406    check( strcmp( "ghi", s ) == 0 );
     407
     408    tr_bencFree( &dest );
     409    tr_bencFree( &src );
     410    return 0;
     411}
     412
    364413static int
    365414testStackSmash( int depth )
     
    397446    int i;
    398447
    399     if( ( i = testInt( ) ) )
    400         return i;
    401 
    402     if( ( i = testStr( ) ) )
    403         return i;
    404 
    405     if( ( i = testParse( ) ) )
    406         return i;
    407 
    408     if( ( i = testJSON( ) ) )
     448    if(( i = testInt( )))
     449        return i;
     450
     451    if(( i = testStr( )))
     452        return i;
     453
     454    if(( i = testParse( )))
     455        return i;
     456
     457    if(( i = testJSON( )))
     458        return i;
     459
     460    if(( i = testMerge( )))
    409461        return i;
    410462
  • trunk/libtransmission/bencode.c

    r7166 r7359  
    3535**/
    3636
    37 int
    38 tr_bencIsType( const tr_benc * val,
    39                int             type )
     37tr_bool
     38tr_bencIsType( const tr_benc * val, int type )
    4039{
    4140    return ( val ) && ( val->type == type );
    4241}
    4342
    44 static int
     43static tr_bool
    4544isContainer( const tr_benc * val )
    4645{
     
    4847}
    4948
    50 static int
     49static tr_bool
    5150isSomething( const tr_benc * val )
    5251{
    53     return isContainer( val ) || tr_bencIsInt( val ) || tr_bencIsString(
    54                val );
     52    return isContainer( val ) || tr_bencIsInt( val ) || tr_bencIsString( val );
    5553}
    5654
     
    383381
    384382tr_benc *
    385 tr_bencDictFind( tr_benc *    val,
    386                  const char * key )
     383tr_bencDictFind( tr_benc * val, const char * key )
    387384{
    388385    const int i = dictIndexOf( val, key );
     
    418415}
    419416
    420 int
     417tr_bool
    421418tr_bencGetInt( const tr_benc * val,
    422419               int64_t *       setme )
     
    429426}
    430427
    431 int
     428tr_bool
    432429tr_bencGetStr( const tr_benc * val,
    433430               const char **   setme )
     
    440437}
    441438
    442 int
    443 tr_bencDictFindInt( tr_benc *    dict,
    444                     const char * key,
    445                     int64_t *    setme )
    446 {
    447     int       found = FALSE;
     439tr_bool
     440tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
     441{
     442    tr_bool found = FALSE;
    448443    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_INT );
    449444
     
    453448}
    454449
    455 int
    456 tr_bencDictFindDouble( tr_benc *    dict,
    457                        const char * key,
    458                        double *     setme )
     450tr_bool
     451tr_bencDictFindDouble( tr_benc * dict, const char * key, double * setme )
    459452{
    460453    const char * str;
    461     const int    success = tr_bencDictFindStr( dict, key, &str );
     454    const tr_bool success = tr_bencDictFindStr( dict, key, &str );
    462455
    463456    if( success )
    464457        *setme = strtod( str, NULL );
     458
    465459    return success;
    466460}
    467461
    468 int
    469 tr_bencDictFindList( tr_benc *    dict,
    470                      const char * key,
    471                      tr_benc **   setme )
    472 {
    473     int       found = FALSE;
     462tr_bool
     463tr_bencDictFindList( tr_benc * dict, const char * key, tr_benc ** setme )
     464{
     465    tr_bool found = FALSE;
    474466    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_LIST );
    475467
     
    479471        found = TRUE;
    480472    }
     473
    481474    return found;
    482475}
    483476
    484 int
    485 tr_bencDictFindDict( tr_benc *    dict,
    486                      const char * key,
    487                      tr_benc **   setme )
    488 {
    489     int       found = FALSE;
     477tr_bool
     478tr_bencDictFindDict( tr_benc * dict, const char * key, tr_benc ** setme )
     479{
     480    tr_bool found = FALSE;
    490481    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_DICT );
    491482
     
    495486        found = TRUE;
    496487    }
     488
    497489    return found;
    498490}
    499491
    500 int
    501 tr_bencDictFindStr( tr_benc *     dict,
    502                     const char *  key,
    503                     const char ** setme )
    504 {
    505     int       found = FALSE;
     492tr_bool
     493tr_bencDictFindStr( tr_benc *  dict, const char *  key, const char ** setme )
     494{
     495    tr_bool found = FALSE;
    506496    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
    507497
     
    511501        found = TRUE;
    512502    }
     503
    513504    return found;
    514505}
    515506
    516 int
    517 tr_bencDictFindRaw( tr_benc *        dict,
    518                     const char *    key,
    519                     const uint8_t ** setme_raw,
    520                     size_t *        setme_len )
    521 {
    522     int      found = FALSE;
     507tr_bool
     508tr_bencDictFindRaw( tr_benc         * dict,
     509                    const char      * key,
     510                    const uint8_t  ** setme_raw,
     511                    size_t          * setme_len )
     512{
     513    tr_bool found = FALSE;
    523514    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
    524515
     
    529520        found = TRUE;
    530521    }
     522
    531523    return found;
    532524}
     
    13171309***/
    13181310
     1311static size_t
     1312tr_bencDictSize( const tr_benc * dict )
     1313{
     1314    size_t count = 0;
     1315
     1316    if( tr_bencIsDict( dict ) )
     1317        count = dict->val.l.count / 2;
     1318
     1319    return count;
     1320}
     1321
     1322static tr_bool
     1323tr_bencDictChild( const tr_benc * dict, size_t n, const char ** key, const tr_benc ** val )
     1324{
     1325    tr_bool success = 0;
     1326
     1327    assert( tr_bencIsDict( dict ) );
     1328
     1329    if( tr_bencIsDict( dict ) && (n*2)+1 <= dict->val.l.count )
     1330    {
     1331        tr_benc * k = dict->val.l.vals + (n*2);
     1332        tr_benc * v = dict->val.l.vals + (n*2) + 1;
     1333        if(( success = tr_bencGetStr( k, key ) && isSomething( v )))
     1334            *val = v;
     1335    }
     1336
     1337    return success;
     1338}
     1339
     1340void
     1341tr_bencMergeDicts( tr_benc * target, const tr_benc * source )
     1342{
     1343    size_t i;
     1344    const size_t sourceCount = tr_bencDictSize( source );
     1345
     1346    assert( tr_bencIsDict( target ) );
     1347    assert( tr_bencIsDict( source ) );
     1348
     1349    for( i=0; i<sourceCount; ++i )
     1350    {
     1351        const char * key;
     1352        const tr_benc * val;
     1353
     1354        if( tr_bencDictChild( source, i, &key, &val ) )
     1355        {
     1356            int64_t i64;
     1357            const char * str;
     1358
     1359            if( tr_bencGetInt( val, &i64 ) )
     1360            {
     1361                tr_bencDictRemove( target, key );
     1362                tr_bencDictAddInt( target, key, i64 );
     1363            }
     1364            else if( tr_bencGetStr( val, &str ) )
     1365            {
     1366                tr_bencDictRemove( target, key );
     1367                tr_bencDictAddStr( target, key, str );
     1368            }
     1369            else
     1370            {
     1371                tr_err( "tr_bencMergeDicts skipping \"%s\"", key );
     1372            }
     1373        }
     1374    }
     1375}
     1376
     1377/***
     1378****
     1379***/
     1380
    13191381static int
    13201382saveFile( const char * filename,
  • trunk/libtransmission/bencode.h

    r6795 r7359  
    7171void      tr_bencFree( tr_benc * );
    7272
    73 char*     tr_bencSave( const tr_benc * val,
    74                        int *           len );
     73char*     tr_bencSave( const tr_benc * val, int * len );
    7574
    76 char*     tr_bencSaveAsJSON( const tr_benc * top,
    77                              int *           len );
     75char*     tr_bencSaveAsJSON( const tr_benc * top, int * len );
    7876
    79 int       tr_bencSaveFile( const char * filename,
    80                            const        tr_benc * );
     77int       tr_bencSaveFile( const char * filename, const tr_benc * );
    8178
    82 int       tr_bencSaveJSONFile( const char * filename,
    83                                const        tr_benc * );
     79int       tr_bencSaveJSONFile( const char * filename, const tr_benc * );
    8480
    85 void      tr_bencInitStr(                       tr_benc *,
    86                                    const void * str,
    87                                    int          str_len );
     81void      tr_bencInitStr( tr_benc *, const void * str, int str_len );
    8882
    89 void      tr_bencInitRaw(                       tr_benc *,
    90                                    const void * raw,
    91                                    size_t       raw_len );
     83void      tr_bencInitRaw( tr_benc *, const void * raw, size_t raw_len );
    9284
    93 void      tr_bencInitInt(             tr_benc *,
    94                               int64_t num );
     85void      tr_bencInitInt( tr_benc *, int64_t num );
    9586
    96 int       tr_bencInitDict(           tr_benc *,
    97                               size_t reserveCount );
     87int       tr_bencInitDict( tr_benc *, size_t reserveCount );
    9888
    99 int       tr_bencInitList(           tr_benc *,
    100                               size_t reserveCount );
     89int       tr_bencInitList( tr_benc *, size_t reserveCount );
    10190
    10291/***
     
    10493***/
    10594
    106 int       tr_bencListReserve(         tr_benc *,
    107                                size_t reserveCount );
     95int       tr_bencListReserve( tr_benc *, size_t reserveCount );
    10896
    10997tr_benc * tr_bencListAdd( tr_benc * );
    11098
    111 tr_benc * tr_bencListAddInt(                 tr_benc *,
    112                                      int64_t val );
     99tr_benc * tr_bencListAddInt( tr_benc *, int64_t val );
    113100
    114 tr_benc * tr_bencListAddStr(                           tr_benc *,
    115                                           const char * val );
     101tr_benc * tr_bencListAddStr( tr_benc *, const char * val );
    116102
    117 tr_benc * tr_bencListAddList(               tr_benc *,
    118                                      size_t reserveCount );
     103tr_benc * tr_bencListAddList( tr_benc *, size_t reserveCount );
    119104
    120 tr_benc * tr_bencListAddDict(               tr_benc *,
    121                                      size_t reserveCount );
     105tr_benc * tr_bencListAddDict( tr_benc *, size_t reserveCount );
    122106
    123107size_t    tr_bencListSize( const tr_benc * list );
    124108
    125 tr_benc * tr_bencListChild( tr_benc * list,
    126                             size_t    n );
     109tr_benc * tr_bencListChild( tr_benc * list, size_t n );
    127110
    128111/***
     
    130113***/
    131114
    132 int       tr_bencDictReserve(         tr_benc *,
    133                                size_t reserveCount );
     115int       tr_bencDictReserve( tr_benc *, size_t reserveCount );
    134116
    135 int       tr_bencDictRemove(                     tr_benc *,
    136                                     const char * key );
     117int       tr_bencDictRemove( tr_benc *, const char * key );
    137118
    138 tr_benc * tr_bencDictAdd(                           tr_benc *,
    139                                        const char * key );
     119tr_benc * tr_bencDictAdd( tr_benc *, const char * key );
    140120
    141 tr_benc * tr_bencDictAddDouble(                           tr_benc *,
    142                                              const char * key,
    143                                              double       d );
     121tr_benc * tr_bencDictAddDouble( tr_benc *, const char * key, double );
    144122
    145 tr_benc * tr_bencDictAddInt(                           tr_benc *,
    146                                           const char * key,
    147                                           int64_t      val );
     123tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t );
    148124
    149 tr_benc * tr_bencDictAddStr(                           tr_benc *,
    150                                           const char * key,
    151                                           const char * val );
     125tr_benc * tr_bencDictAddStr( tr_benc *, const char * key, const char * );
    152126
    153 tr_benc * tr_bencDictAddList(                           tr_benc *,
    154                                            const char * key,
    155                                            size_t       reserve );
     127tr_benc * tr_bencDictAddList( tr_benc *, const char * key, size_t reserve );
    156128
    157 tr_benc * tr_bencDictAddDict(                           tr_benc *,
    158                                            const char * key,
    159                                            size_t       reserve );
     129tr_benc * tr_bencDictAddDict( tr_benc *, const char * key, size_t reserve );
    160130
    161 tr_benc * tr_bencDictAddRaw(                           tr_benc *,
    162                                           const char * key,
    163                                           const        void *,
    164                                           size_t       len );
     131tr_benc * tr_bencDictAddRaw( tr_benc *, const char * key,
     132                             const void * raw, size_t rawlen );
    165133
    166 tr_benc*  tr_bencDictFind(                          tr_benc *,
    167                                        const char * key );
     134tr_benc*  tr_bencDictFind( tr_benc *, const char * key );
    168135
    169 int       tr_bencDictFindList(                     tr_benc *,
    170                                       const char * key,
    171                                       tr_benc **   setme );
     136tr_bool   tr_bencDictFindList( tr_benc *, const char * key, tr_benc ** setme );
    172137
    173 int       tr_bencDictFindDict(                     tr_benc *,
    174                                       const char * key,
    175                                       tr_benc **   setme );
     138tr_bool   tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
    176139
    177 int       tr_bencDictFindInt(                     tr_benc *,
    178                                      const char * key,
    179                                      int64_t *    setme );
     140tr_bool   tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
    180141
    181 int       tr_bencDictFindDouble(                     tr_benc *,
    182                                         const char * key,
    183                                         double *     setme );
     142tr_bool   tr_bencDictFindDouble( tr_benc *, const char * key, double * setme );
    184143
    185 int       tr_bencDictFindStr(                       tr_benc *,
    186                                       const char *  key,
    187                                       const char ** setme );
     144tr_bool   tr_bencDictFindStr( tr_benc *, const char * key, const char ** setme );
    188145
    189 int       tr_bencDictFindRaw(                             tr_benc *,
    190                                          const char *     key,
    191                                          const uint8_t ** setme_raw,
    192                                          size_t *         setme_len );
     146tr_bool   tr_bencDictFindRaw( tr_benc *, const char * key,
     147                              const uint8_t ** setme_raw, size_t * setme_len );
    193148
    194149/***
     
    196151***/
    197152
    198 int       tr_bencGetInt( const tr_benc * val,
    199                          int64_t *       setme );
     153tr_bool   tr_bencGetInt( const tr_benc * val, int64_t * setme );
    200154
    201 int       tr_bencGetStr( const tr_benc * val,
    202                          const char **   setme );
     155tr_bool   tr_bencGetStr( const tr_benc * val, const char ** setme );
    203156
    204 int       tr_bencIsType( const tr_benc *,
    205                          int   type );
     157tr_bool   tr_bencIsType( const tr_benc *, int type );
     158
    206159
    207160#define tr_bencIsInt( b )    tr_bencIsType( ( b ), TYPE_INT )
     
    226179                     size_t *         setme_strlen );
    227180
     181/**
     182***
     183**/
     184
     185void  tr_bencMergeDicts( tr_benc * b1, const tr_benc * b2 );
     186
    228187#endif
Note: See TracChangeset for help on using the changeset viewer.