Changeset 98dc1ba for test


Ignore:
Timestamp:
02/27/15 18:05:18 (6 years ago)
Author:
Richard Sanger <rsangerarj@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
e7d3bdc
Parents:
0ec8a7c
Message:

Update tests to use the updated interface.

Also fixes some compile time warnings

Location:
test
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • test/test-format-parallel-hasher.c

    r0ec8a7c r98dc1ba  
    126126
    127127static int x;
    128 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    129                                                 libtrace_message_t *mesg,
    130                                                 libtrace_thread_t *t) {
     128static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     129                        int mesg, libtrace_generic_t data,
     130                        libtrace_thread_t *sender UNUSED) {
    131131        struct TLS *tls;
    132132        void* ret;
    133133        tls = trace_get_tls(t);
    134 
    135         if (pkt) {
    136                 int a,*b,c=0;
     134        int a,*b,c=0;
     135
     136        switch (mesg) {
     137        case MESSAGE_PACKET:
    137138                assert(tls != NULL);
    138139                assert(!(tls->seen_stop_message));
     
    148149                }
    149150                x = c;
    150         }
    151         else switch (mesg->code) {
    152                 case MESSAGE_STARTING:
    153                         assert(tls == NULL);
    154                         tls = calloc(sizeof(struct TLS), 1);
    155                         ret = trace_set_tls(t, tls);
    156                         assert(ret == NULL);
    157                         tls->seen_start_message = true;
    158                         break;
    159                 case MESSAGE_STOPPING:
    160                         assert(tls->seen_start_message);
    161                         assert(tls != NULL);
    162                         tls->seen_stop_message = true;
    163                         trace_set_tls(t, NULL);
    164 
    165                         // All threads publish to verify the thread count
    166                         assert(tls->count == 25 || tls->count == 75);
    167                         trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
    168                         trace_post_reporter(trace);
    169                         free(tls);
    170                         break;
    171                 case MESSAGE_TICK:
    172                         assert(tls->seen_start_message );
    173                         fprintf(stderr, "Not expecting a tick packet\n");
    174                         kill(getpid(), SIGTERM);
    175                         break;
    176                 case MESSAGE_PAUSING:
    177                         assert(tls->seen_start_message);
    178                         tls->seen_pausing_message = true;
    179                         break;
    180                 case MESSAGE_RESUMING:
    181                         assert(tls->seen_pausing_message  || tls->seen_start_message);
    182                         tls->seen_resumed_message = true;
    183                         break;
    184         }
    185         return pkt;
     151                return data.pkt;
     152        case MESSAGE_STARTING:
     153                assert(tls == NULL);
     154                tls = calloc(sizeof(struct TLS), 1);
     155                ret = trace_set_tls(t, tls);
     156                assert(ret == NULL);
     157                tls->seen_start_message = true;
     158                break;
     159        case MESSAGE_STOPPING:
     160                assert(tls->seen_start_message);
     161                assert(tls != NULL);
     162                tls->seen_stop_message = true;
     163                trace_set_tls(t, NULL);
     164
     165                // All threads publish to verify the thread count
     166                assert(tls->count == 25 || tls->count == 75);
     167                trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
     168                trace_post_reporter(trace);
     169                free(tls);
     170                break;
     171        case MESSAGE_TICK:
     172                assert(tls->seen_start_message );
     173                fprintf(stderr, "Not expecting a tick packet\n");
     174                kill(getpid(), SIGTERM);
     175                break;
     176        case MESSAGE_PAUSING:
     177                assert(tls->seen_start_message);
     178                tls->seen_pausing_message = true;
     179                break;
     180        case MESSAGE_RESUMING:
     181                assert(tls->seen_pausing_message  || tls->seen_start_message);
     182                tls->seen_resumed_message = true;
     183                break;
     184        }
     185        return NULL;
    186186}
    187187
     
    192192 * might change and still be valid even if this test fails!!.
    193193 */
    194 uint64_t hash25_75(const libtrace_packet_t* packet, void *data) {
     194uint64_t hash25_75(const libtrace_packet_t* packet UNUSED, void *data) {
    195195        int *count = (int *) data;
    196196        *count += 1;
  • test/test-format-parallel-reporter.c

    r0ec8a7c r98dc1ba  
    119119}
    120120
    121 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    122                                                 libtrace_message_t *mesg,
    123                                                 libtrace_thread_t *t) {
     121static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     122                        int mesg, libtrace_generic_t data,
     123                        libtrace_thread_t *sender UNUSED) {
    124124        UNUSED static __thread int x = 0;
    125         if (pkt) {
     125
     126        if (mesg == MESSAGE_PACKET) {
    126127                int a,*b,c=0;
    127128                // Do some work to even out the load on cores
     
    131132                }
    132133                x = c;
    133                 trace_publish_result(trace, t, trace_packet_get_order(pkt), (libtrace_generic_t){.pkt=pkt}, RESULT_PACKET);
    134                 return NULL;
     134                trace_publish_result(trace, t, trace_packet_get_order(data.pkt), (libtrace_generic_t){.pkt=data.pkt}, RESULT_PACKET);
    135135        }
    136         else switch (mesg->code) {
    137                 // We don't care we have no state
    138                 default:
    139                         break;
    140         }
    141         return pkt;
     136        return NULL;
    142137}
    143138
  • test/test-format-parallel-singlethreaded-hasher.c

    r0ec8a7c r98dc1ba  
    125125
    126126static int x;
    127 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    128                                                 libtrace_message_t *mesg,
    129                                                 libtrace_thread_t *t) {
     127static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     128                        int mesg, libtrace_generic_t data,
     129                        libtrace_thread_t *sender UNUSED) {
    130130        struct TLS *tls;
    131131        void* ret;
     132        int a,*b,c=0;
    132133        tls = trace_get_tls(t);
    133134
    134         if (pkt) {
    135                 int a,*b,c=0;
     135        switch (mesg) {
     136        case MESSAGE_PACKET:
    136137                assert(tls != NULL);
    137138                assert(!(tls->seen_stop_message));
     
    147148                }
    148149                x = c;
    149         }
    150         else switch (mesg->code) {
    151                 case MESSAGE_STARTING:
    152                         assert(tls == NULL);
    153                         tls = calloc(sizeof(struct TLS), 1);
    154                         ret = trace_set_tls(t, tls);
    155                         assert(ret == NULL);
    156                         tls->seen_start_message = true;
    157                         break;
    158                 case MESSAGE_STOPPING:
    159                         assert(tls->seen_start_message);
    160                         assert(tls != NULL);
    161                         tls->seen_stop_message = true;
    162                         trace_set_tls(t, NULL);
    163 
    164                         // All threads publish to verify the thread count
    165                         trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
    166                         trace_post_reporter(trace);
    167                         free(tls);
    168                         break;
    169                 case MESSAGE_TICK:
    170                         assert(tls->seen_start_message );
    171                         fprintf(stderr, "Not expecting a tick packet\n");
    172                         kill(getpid(), SIGTERM);
    173                         break;
    174                 case MESSAGE_PAUSING:
    175                         assert(tls->seen_start_message);
    176                         tls->seen_pausing_message = true;
    177                         break;
    178                 case MESSAGE_RESUMING:
    179                         assert(tls->seen_pausing_message || tls->seen_start_message);
    180                         tls->seen_resuming_message = true;
    181                         break;
    182         }
    183         return pkt;
     150                return data.pkt;
     151        case MESSAGE_STARTING:
     152                assert(tls == NULL);
     153                tls = calloc(sizeof(struct TLS), 1);
     154                ret = trace_set_tls(t, tls);
     155                assert(ret == NULL);
     156                tls->seen_start_message = true;
     157                break;
     158        case MESSAGE_STOPPING:
     159                assert(tls->seen_start_message);
     160                assert(tls != NULL);
     161                tls->seen_stop_message = true;
     162                trace_set_tls(t, NULL);
     163
     164                // All threads publish to verify the thread count
     165                trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
     166                trace_post_reporter(trace);
     167                free(tls);
     168                break;
     169        case MESSAGE_TICK:
     170                assert(tls->seen_start_message );
     171                fprintf(stderr, "Not expecting a tick packet\n");
     172                kill(getpid(), SIGTERM);
     173                break;
     174        case MESSAGE_PAUSING:
     175                assert(tls->seen_start_message);
     176                tls->seen_pausing_message = true;
     177                break;
     178        case MESSAGE_RESUMING:
     179                assert(tls->seen_pausing_message || tls->seen_start_message);
     180                tls->seen_resuming_message = true;
     181                break;
     182        }
     183        return NULL;
    184184}
    185185
     
    189189 * might change and still be valid even if this test fails!!.
    190190 */
    191 uint64_t hash25_75(const libtrace_packet_t* packet, void *data) {
     191uint64_t hash25_75(const libtrace_packet_t* packet UNUSED, void *data) {
    192192        int *count = (int *) data;
    193193        *count += 1;
  • test/test-format-parallel-singlethreaded.c

    r0ec8a7c r98dc1ba  
    124124
    125125static int x;
    126 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    127                                                 libtrace_message_t *mesg,
    128                                                 libtrace_thread_t *t) {
     126static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     127                        int mesg, libtrace_generic_t data,
     128                        libtrace_thread_t *sender UNUSED) {
    129129        struct TLS *tls;
    130130        void* ret;
     131        int a,*b,c=0;
    131132        tls = trace_get_tls(t);
    132133
    133         if (pkt) {
    134                 int a,*b,c=0;
     134        switch (mesg) {
     135        case MESSAGE_PACKET:
    135136                assert(tls != NULL);
    136137                assert(!(tls->seen_stop_message));
     
    146147                }
    147148                x = c;
    148         }
    149         else switch (mesg->code) {
    150                 case MESSAGE_STARTING:
    151                         assert(tls == NULL);
    152                         tls = calloc(sizeof(struct TLS), 1);
    153                         ret = trace_set_tls(t, tls);
    154                         assert(ret == NULL);
    155                         tls->seen_start_message = true;
    156                         break;
    157                 case MESSAGE_STOPPING:
    158                         assert(tls->seen_start_message);
    159                         assert(tls != NULL);
    160                         tls->seen_stop_message = true;
    161                         trace_set_tls(t, NULL);
    162 
    163                         // All threads publish to verify the thread count
    164                         trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
    165                         trace_post_reporter(trace);
    166                         free(tls);
    167                         break;
    168                 case MESSAGE_TICK:
    169                         assert(tls->seen_start_message );
    170                         fprintf(stderr, "Not expecting a tick packet\n");
    171                         kill(getpid(), SIGTERM);
    172                         break;
    173                 case MESSAGE_PAUSING:
    174                         assert(tls->seen_start_message);
    175                         tls->seen_pausing_message = true;
    176                         break;
    177                 case MESSAGE_RESUMING:
    178                         assert(tls->seen_pausing_message || tls->seen_start_message);
    179                         tls->seen_resuming_message = true;
    180                         break;
    181         }
    182         return pkt;
     149                return data.pkt;
     150        case MESSAGE_STARTING:
     151                assert(tls == NULL);
     152                tls = calloc(sizeof(struct TLS), 1);
     153                ret = trace_set_tls(t, tls);
     154                assert(ret == NULL);
     155                tls->seen_start_message = true;
     156                break;
     157        case MESSAGE_STOPPING:
     158                assert(tls->seen_start_message);
     159                assert(tls != NULL);
     160                tls->seen_stop_message = true;
     161                trace_set_tls(t, NULL);
     162
     163                // All threads publish to verify the thread count
     164                trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
     165                trace_post_reporter(trace);
     166                free(tls);
     167                break;
     168        case MESSAGE_TICK:
     169                assert(tls->seen_start_message );
     170                fprintf(stderr, "Not expecting a tick packet\n");
     171                kill(getpid(), SIGTERM);
     172                break;
     173        case MESSAGE_PAUSING:
     174                assert(tls->seen_start_message);
     175                tls->seen_pausing_message = true;
     176                break;
     177        case MESSAGE_RESUMING:
     178                assert(tls->seen_pausing_message || tls->seen_start_message);
     179                tls->seen_resuming_message = true;
     180                break;
     181        }
     182        return NULL;
    183183}
    184184
  • test/test-format-parallel-stressthreads.c

    r0ec8a7c r98dc1ba  
    124124
    125125static int x;
    126 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    127                                                 libtrace_message_t *mesg,
    128                                                 libtrace_thread_t *t) {
     126static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     127                        int mesg, libtrace_generic_t data,
     128                        libtrace_thread_t *sender UNUSED) {
    129129        struct TLS *tls;
    130130        void* ret;
     131        int a,*b,c=0;
    131132        tls = trace_get_tls(t);
    132133
    133         if (pkt) {
    134                 int a,*b,c=0;
     134        switch (mesg) {
    135135                assert(tls != NULL);
    136136                assert(!(tls->seen_stop_message));
     
    146146                }
    147147                x = c;
    148         }
    149         else switch (mesg->code) {
    150                 case MESSAGE_STARTING:
    151                         assert(tls == NULL);
    152                         tls = calloc(sizeof(struct TLS), 1);
    153                         ret = trace_set_tls(t, tls);
    154                         assert(ret == NULL);
    155                         tls->seen_start_message = true;
    156                         break;
    157                 case MESSAGE_STOPPING:
    158                         assert(tls->seen_start_message);
    159                         assert(tls != NULL);
    160                         tls->seen_stop_message = true;
    161                         trace_set_tls(t, NULL);
    162 
    163                         // All threads publish to verify the thread count
    164                         trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
    165                         trace_post_reporter(trace);
    166                         free(tls);
    167                         break;
    168                 case MESSAGE_TICK:
    169                         assert(tls->seen_start_message );
    170                         fprintf(stderr, "Not expecting a tick packet\n");
    171                         kill(getpid(), SIGTERM);
    172                         break;
    173                 case MESSAGE_PAUSING:
    174                         assert(tls->seen_start_message);
    175                         tls->seen_pausing_message = true;
    176                         break;
    177                 case MESSAGE_RESUMING:
    178                         assert(tls->seen_pausing_message || tls->seen_start_message);
    179                         tls->seen_resuming_message = true;
    180                         break;
    181         }
    182         return pkt;
     148                return data.pkt;
     149        case MESSAGE_STARTING:
     150                assert(tls == NULL);
     151                tls = calloc(sizeof(struct TLS), 1);
     152                ret = trace_set_tls(t, tls);
     153                assert(ret == NULL);
     154                tls->seen_start_message = true;
     155                break;
     156        case MESSAGE_STOPPING:
     157                assert(tls->seen_start_message);
     158                assert(tls != NULL);
     159                tls->seen_stop_message = true;
     160                trace_set_tls(t, NULL);
     161
     162                // All threads publish to verify the thread count
     163                trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint=tls->count}, RESULT_NORMAL);
     164                trace_post_reporter(trace);
     165                free(tls);
     166                break;
     167        case MESSAGE_TICK:
     168                assert(tls->seen_start_message );
     169                fprintf(stderr, "Not expecting a tick packet\n");
     170                kill(getpid(), SIGTERM);
     171                break;
     172        case MESSAGE_PAUSING:
     173                assert(tls->seen_start_message);
     174                tls->seen_pausing_message = true;
     175                break;
     176        case MESSAGE_RESUMING:
     177                assert(tls->seen_pausing_message || tls->seen_start_message);
     178                tls->seen_resuming_message = true;
     179                break;
     180        }
     181        return NULL;
    183182}
    184183
  • test/test-format-parallel.c

    r0ec8a7c r98dc1ba  
    121121
    122122int x;
    123 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    124                                                 libtrace_message_t *mesg,
    125                                                 libtrace_thread_t *t) {
     123static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     124                        int mesg, libtrace_generic_t data,
     125                        libtrace_thread_t *sender UNUSED) {
    126126        struct TLS *tls;
    127127        void* ret;
     128        int a,*b,c=0;
    128129        // Test internal TLS against __thread
    129130        static __thread bool seen_start_message = false;
    130131        static __thread bool seen_stop_message = false;
    131         static __thread bool seen_paused_message = false;
     132        static __thread bool seen_resuming_message = false;
    132133        static __thread bool seen_pausing_message = false;
    133134        static __thread int count = 0;
    134135        tls = trace_get_tls(t);
    135136
    136         if (pkt) {
    137                 int a,*b,c=0;
     137        switch (mesg) {
     138        case MESSAGE_PACKET:
    138139                assert(tls != NULL);
    139140                assert(!seen_stop_message);
     
    150151                }
    151152                x = c;
    152         }
    153         else switch (mesg->code) {
    154                 case MESSAGE_STARTING:
    155                         assert(!seen_start_message || seen_paused_message);
    156                         assert(tls == NULL);
    157                         tls = calloc(sizeof(struct TLS), 1);
    158                         ret = trace_set_tls(t, tls);
    159                         assert(ret == NULL);
    160                         seen_start_message = true;
    161                         tls->seen_start_message = true;
    162                         break;
    163                 case MESSAGE_STOPPING:
    164                         assert(seen_start_message);
    165                         assert(tls != NULL);
    166                         assert(tls->seen_start_message);
    167                         assert(tls->count == count);
    168                         seen_stop_message = true;
    169                         tls->seen_stop_message = true;
    170                         free(tls);
    171                         trace_set_tls(t, NULL);
    172 
    173                         // All threads publish to verify the thread count
    174                         trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint = count}, RESULT_NORMAL);
    175                         trace_post_reporter(trace);
    176                         break;
    177                 case MESSAGE_TICK:
    178                         assert(seen_start_message);
    179                         fprintf(stderr, "Not expecting a tick packet\n");
    180                         kill(getpid(), SIGTERM);
    181                         break;
    182                 case MESSAGE_PAUSING:
    183                         assert(seen_start_message);
    184                         seen_pausing_message = true;
    185                         tls->seen_pausing_message = true;
    186                         break;
    187                 case MESSAGE_RESUMING:
    188                         assert(tls->seen_pausing_message  || tls->seen_start_message );
    189                         seen_paused_message = true;
    190                         tls->seen_resuming_message = true;
    191                         break;
    192         }
    193         return pkt;
     153                return data.pkt;
     154        case MESSAGE_STARTING:
     155                assert(!seen_start_message || seen_resuming_message);
     156                assert(tls == NULL);
     157                tls = calloc(sizeof(struct TLS), 1);
     158                ret = trace_set_tls(t, tls);
     159                assert(ret == NULL);
     160                seen_start_message = true;
     161                tls->seen_start_message = true;
     162                break;
     163        case MESSAGE_STOPPING:
     164                assert(seen_start_message);
     165                assert(tls != NULL);
     166                assert(tls->seen_start_message);
     167                assert(tls->count == count);
     168                seen_stop_message = true;
     169                tls->seen_stop_message = true;
     170                free(tls);
     171                trace_set_tls(t, NULL);
     172
     173                // All threads publish to verify the thread count
     174                trace_publish_result(trace, t, (uint64_t) 0, (libtrace_generic_t){.sint = count}, RESULT_NORMAL);
     175                trace_post_reporter(trace);
     176                break;
     177        case MESSAGE_TICK:
     178                assert(seen_start_message);
     179                fprintf(stderr, "Not expecting a tick packet\n");
     180                kill(getpid(), SIGTERM);
     181                break;
     182        case MESSAGE_PAUSING:
     183                assert(seen_start_message);
     184                seen_pausing_message = true;
     185                tls->seen_pausing_message = true;
     186                break;
     187        case MESSAGE_RESUMING:
     188                assert(tls->seen_pausing_message  || tls->seen_start_message );
     189                seen_resuming_message = true;
     190                tls->seen_resuming_message = true;
     191                break;
     192        }
     193        return NULL;
    194194}
    195195
Note: See TracChangeset for help on using the changeset viewer.