Mercurial > hg > webserver / file comparison

comparison: src/server/test/event.c

src/server/test/event.c

changeset 633
392ec9026b07
parent 552
4ed0e46aa9dc
equal deleted inserted replaced
632:1defab20b477 633:392ec9026b07
38 void *data2; 38 void *data2;
39 int i1; 39 int i1;
40 int i2; 40 int i2;
41 } EVTest; 41 } EVTest;
42 42
43 UCX_TEST(test_evhandler_create) { 43 CX_TEST(test_evhandler_create) {
44 EventHandlerConfig cfg1 = { .nthreads = 1}; 44 EventHandlerConfig cfg1 = { .nthreads = 1};
45 45
46 EventHandlerConfig cfg4 = { .nthreads = 4}; 46 EventHandlerConfig cfg4 = { .nthreads = 4};
47 47
48 UCX_TEST_BEGIN; 48 CX_TEST_DO {
49 49 EVHandler *ev1 = evhandler_create(&cfg1);
50 EVHandler *ev1 = evhandler_create(&cfg1); 50 CX_TEST_ASSERT(ev1);
51 UCX_TEST_ASSERT(ev1, "evhandler_create (1) failed"); 51 CX_TEST_ASSERT(ev1->numins == 1);
52 UCX_TEST_ASSERT(ev1->numins == 1, "ev1 wrong number of instances"); 52
53 53 EVHandler *ev2 = evhandler_create(&cfg4);
54 EVHandler *ev2 = evhandler_create(&cfg4); 54 CX_TEST_ASSERT(ev2);
55 UCX_TEST_ASSERT(ev2, "evhandler_create (2) failed"); 55 CX_TEST_ASSERT(ev2->numins == 4);
56 UCX_TEST_ASSERT(ev2->numins == 4, "ev2 wrong number of instances"); 56
57 57
58 58 evhandler_shutdown(ev1);
59 evhandler_shutdown(ev1); 59 evhandler_shutdown(ev2);
60 evhandler_shutdown(ev2); 60
61 61 evhandler_wait_and_destroy(ev1);
62 evhandler_wait_and_destroy(ev1); 62 evhandler_wait_and_destroy(ev2);
63 evhandler_wait_and_destroy(ev2); 63 }
64
65 UCX_TEST_END;
66 } 64 }
67 65
68 static int test_event_send_fn(EventHandler *h, Event *event) { 66 static int test_event_send_fn(EventHandler *h, Event *event) {
69 EVTest *test = event->cookie; 67 EVTest *test = event->cookie;
70 test->i1 = 1; 68 test->i1 = 1;
89 pthread_cond_wait(&testdata->cond, &testdata->mutex); 87 pthread_cond_wait(&testdata->cond, &testdata->mutex);
90 pthread_mutex_unlock(&testdata->mutex); 88 pthread_mutex_unlock(&testdata->mutex);
91 } 89 }
92 } 90 }
93 91
94 UCX_TEST(test_event_send) { 92 CX_TEST(test_event_send) {
95 EventHandlerConfig cfg = { .nthreads = 1}; 93 EventHandlerConfig cfg = { .nthreads = 1};
96 94
97 EVHandler *ev = evhandler_create(&cfg); 95 EVHandler *ev = evhandler_create(&cfg);
98 EventHandler *h = ev_instance(ev); 96 EventHandler *h = ev_instance(ev);
99 97
101 ZERO(&testdata, sizeof(EVTest)); 99 ZERO(&testdata, sizeof(EVTest));
102 testdata.h = h; 100 testdata.h = h;
103 pthread_mutex_init(&testdata.mutex, NULL); 101 pthread_mutex_init(&testdata.mutex, NULL);
104 pthread_cond_init(&testdata.cond, NULL); 102 pthread_cond_init(&testdata.cond, NULL);
105 103
106 UCX_TEST_BEGIN; 104 CX_TEST_DO {
107 105
108 // test sending a single event 106 // test sending a single event
109 // the event signals completion in the testdata object 107 // the event signals completion in the testdata object
110 // wait up to 10 seconds for completion (it should be instantly) 108 // wait up to 10 seconds for completion (it should be instantly)
111 109
112 Event evt; 110 Event evt;
113 ZERO(&evt, sizeof(Event)); 111 ZERO(&evt, sizeof(Event));
114 evt.fn = test_event_send_fn; 112 evt.fn = test_event_send_fn;
115 evt.cookie = &testdata; 113 evt.cookie = &testdata;
116 114
117 int ret = event_send(h, &evt); 115 int ret = event_send(h, &evt);
118 116
119 // wait for event finish 117 // wait for event finish
120 testdata_wait_for_completion(&testdata); 118 testdata_wait_for_completion(&testdata);
121 119
122 UCX_TEST_ASSERT(!ret, "event_send failed"); 120 CX_TEST_ASSERT(!ret);
123 UCX_TEST_ASSERT(testdata.i1, "event callback not called"); 121 CX_TEST_ASSERT(testdata.i1);
124 UCX_TEST_ASSERT(testdata.i2, "event callback received wrong event handler pointer"); 122 CX_TEST_ASSERT(testdata.i2);
125 123
126 UCX_TEST_END; 124 }
127 125
128 pthread_mutex_destroy(&testdata.mutex); 126 pthread_mutex_destroy(&testdata.mutex);
129 pthread_cond_destroy(&testdata.cond); 127 pthread_cond_destroy(&testdata.cond);
130 128
131 evhandler_shutdown(ev); 129 evhandler_shutdown(ev);
174 event_send(h, finish_event); 172 event_send(h, finish_event);
175 173
176 return 0; 174 return 0;
177 } 175 }
178 176
179 UCX_TEST(test_event_send_multi) { 177 CX_TEST(test_event_send_multi) {
180 EventHandlerConfig cfg = { .nthreads = 1}; 178 EventHandlerConfig cfg = { .nthreads = 1};
181 179
182 EVHandler *ev = evhandler_create(&cfg); 180 EVHandler *ev = evhandler_create(&cfg);
183 EventHandler *h = ev_instance(ev); 181 EventHandler *h = ev_instance(ev);
184 182
186 ZERO(&testdata, sizeof(EVTest)); 184 ZERO(&testdata, sizeof(EVTest));
187 testdata.h = h; 185 testdata.h = h;
188 pthread_mutex_init(&testdata.mutex, NULL); 186 pthread_mutex_init(&testdata.mutex, NULL);
189 pthread_cond_init(&testdata.cond, NULL); 187 pthread_cond_init(&testdata.cond, NULL);
190 188
191 UCX_TEST_BEGIN; 189 CX_TEST_DO {
192 190
193 // test sending multiple events 191 // test sending multiple events
194 // the first callback test_event_send_multi_fn1 adds additional 192 // the first callback test_event_send_multi_fn1 adds additional
195 // EV_TEST_NUM_EVENTS events to the handler + an additional 193 // EV_TEST_NUM_EVENTS events to the handler + an additional
196 // finishing event, that notifies completion 194 // finishing event, that notifies completion
197 195
198 Event evt; 196 Event evt;
199 ZERO(&evt, sizeof(Event)); 197 ZERO(&evt, sizeof(Event));
200 evt.fn = test_event_send_multi_fn1; 198 evt.fn = test_event_send_multi_fn1;
201 evt.cookie = &testdata; 199 evt.cookie = &testdata;
202 200
203 int ret = event_send(h, &evt); 201 int ret = event_send(h, &evt);
204 202
205 // wait for event finish 203 // wait for event finish
206 testdata_wait_for_completion(&testdata); 204 testdata_wait_for_completion(&testdata);
207 205
208 UCX_TEST_ASSERT(!ret, "event_send failed"); 206 CX_TEST_ASSERT(!ret);
209 UCX_TEST_ASSERT(testdata.i1, "event callback not called"); 207 CX_TEST_ASSERT(testdata.i1);
210 UCX_TEST_ASSERT(testdata.i2 == EV_TEST_NUM_EVENTS, "event callback received wrong event handler pointer"); 208 CX_TEST_ASSERT(testdata.i2 == EV_TEST_NUM_EVENTS);
211 209
212 UCX_TEST_END; 210 }
213 211
214 pthread_mutex_destroy(&testdata.mutex); 212 pthread_mutex_destroy(&testdata.mutex);
215 pthread_cond_destroy(&testdata.cond); 213 pthread_cond_destroy(&testdata.cond);
216 214
217 evhandler_shutdown(ev); 215 evhandler_shutdown(ev);

Mercurial Repository: webserver

mercurial