← Back to branch summary

~ubuntu-branches/ubuntu/wily/weechat/wily

« back to all changes in this revision

Viewing changes to tests/unit/core/test-list.cpp

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bouthenot
  • Date: 2015-08-19 18:34:17 UTC
  • mfrom: (29.1.11 sid)
  • Revision ID: package-import@ubuntu.com-20150819183417-u026z5wo8knpcdqd
Tags: 1.3-1
http://bugs.debian.org/794584
* New upstream release
  - Remove backported patch to fix FTBFS with ruby 2.2
* Use dh-exec to build javascript plugin only on architectures which v8
  engine supports. Thanks to Mateusz Łukasik for the patch
  (Closes: #794584)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit/core/test-list.cpp
24
24
extern "C"
25
25
{
26
26
#include "src/core/wee-list.h"
 
27
#include "src/plugins/plugin.h"
27
28
}
28
29
 
 
30
#define LIST_VALUE_TEST "test"
 
31
#define LIST_VALUE_XYZ  "xyz"
 
32
#define LIST_VALUE_ZZZ  "zzz"
 
33
 
29
34
TEST_GROUP(List)
30
35
{
31
36
};
32
37
 
33
38
/*
 
39
 * Creates a list for tests.
 
40
 */
 
41
 
 
42
struct t_weelist *
 
43
test_list_new ()
 
44
{
 
45
    struct t_weelist *list;
 
46
 
 
47
    list = weelist_new ();
 
48
 
 
49
    weelist_add (list, LIST_VALUE_ZZZ, WEECHAT_LIST_POS_END, NULL);
 
50
    weelist_add (list, LIST_VALUE_TEST, WEECHAT_LIST_POS_BEGINNING, NULL);
 
51
    weelist_add (list, LIST_VALUE_XYZ, WEECHAT_LIST_POS_SORT, NULL);
 
52
 
 
53
    return list;
 
54
}
 
55
 
 
56
/*
34
57
 * Tests functions:
35
58
 *   weelist_new
36
59
 */
37
60
 
38
61
TEST(List, New)
39
62
{
40
 
    /* TODO: write tests */
 
63
    struct t_weelist *list;
 
64
 
 
65
    list = weelist_new();
 
66
    CHECK(list);
 
67
 
 
68
    /* check initial values */
 
69
    POINTERS_EQUAL(NULL, list->items);
 
70
    POINTERS_EQUAL(NULL, list->last_item);
 
71
    LONGS_EQUAL(0, list->size);
 
72
 
 
73
    /* free list */
 
74
    weelist_free (list);
41
75
}
42
76
 
43
77
/*
44
78
 * Tests functions:
45
79
 *   weelist_add
 
80
 *   weelist_free
46
81
 */
47
82
 
48
83
TEST(List, Add)
49
84
{
50
 
    /* TODO: write tests */
 
85
    struct t_weelist *list;
 
86
    struct t_weelist_item *item1, *item2, *item3;
 
87
    const char *str_user_data = "some user data";
 
88
 
 
89
    list = weelist_new();
 
90
 
 
91
    POINTERS_EQUAL(NULL, weelist_add (NULL, NULL, NULL, NULL));
 
92
    POINTERS_EQUAL(NULL, weelist_add (list, NULL, NULL, NULL));
 
93
    POINTERS_EQUAL(NULL, weelist_add (NULL, LIST_VALUE_TEST, NULL, NULL));
 
94
    POINTERS_EQUAL(NULL, weelist_add (NULL, NULL, WEECHAT_LIST_POS_END, NULL));
 
95
    POINTERS_EQUAL(NULL, weelist_add (list, LIST_VALUE_TEST, NULL, NULL));
 
96
    POINTERS_EQUAL(NULL, weelist_add (list, NULL, WEECHAT_LIST_POS_END, NULL));
 
97
    POINTERS_EQUAL(NULL, weelist_add (NULL, LIST_VALUE_TEST,
 
98
                                      WEECHAT_LIST_POS_END, NULL));
 
99
 
 
100
    /* add an element at the end */
 
101
    item1 = weelist_add (list, LIST_VALUE_ZZZ, WEECHAT_LIST_POS_END,
 
102
                         (void *)str_user_data);
 
103
    CHECK(item1);
 
104
    CHECK(item1->data);
 
105
    CHECK(item1->user_data);
 
106
    STRCMP_EQUAL(LIST_VALUE_ZZZ, item1->data);
 
107
    POINTERS_EQUAL(str_user_data, item1->user_data);
 
108
    LONGS_EQUAL(1, list->size);  /* list is now: ["zzz"] */
 
109
    POINTERS_EQUAL(item1, list->items);
 
110
 
 
111
    /* add an element at the beginning */
 
112
    item2 = weelist_add (list, LIST_VALUE_TEST, WEECHAT_LIST_POS_BEGINNING,
 
113
                         (void *)str_user_data);
 
114
    CHECK(item2);
 
115
    CHECK(item2->data);
 
116
    CHECK(item2->user_data);
 
117
    STRCMP_EQUAL(LIST_VALUE_TEST, item2->data);
 
118
    POINTERS_EQUAL(str_user_data, item2->user_data);
 
119
    LONGS_EQUAL(2, list->size);  /* list is now: ["test", "zzz"] */
 
120
    POINTERS_EQUAL(item2, list->items);
 
121
    POINTERS_EQUAL(item1, list->items->next_item);
 
122
 
 
123
    /* add an element, using sort */
 
124
    item3 = weelist_add (list, LIST_VALUE_XYZ, WEECHAT_LIST_POS_SORT,
 
125
                         (void *)str_user_data);
 
126
    CHECK(item3);
 
127
    CHECK(item3->data);
 
128
    CHECK(item3->user_data);
 
129
    STRCMP_EQUAL(LIST_VALUE_XYZ, item3->data);
 
130
    POINTERS_EQUAL(str_user_data, item3->user_data);
 
131
    LONGS_EQUAL(3, list->size);  /* list is now: ["test", "xyz", "zzz"] */
 
132
    POINTERS_EQUAL(item2, list->items);
 
133
    POINTERS_EQUAL(item3, list->items->next_item);
 
134
    POINTERS_EQUAL(item1, list->items->next_item->next_item);
 
135
 
 
136
    /* free list */
 
137
    weelist_free (list);
51
138
}
52
139
 
53
140
/*
60
147
 
61
148
TEST(List, Search)
62
149
{
63
 
    /* TODO: write tests */
 
150
    struct t_weelist *list;
 
151
    struct t_weelist_item *ptr_item;
 
152
 
 
153
    list = test_list_new ();
 
154
 
 
155
    /* search an element */
 
156
 
 
157
    POINTERS_EQUAL(NULL, weelist_search (NULL, NULL));
 
158
    POINTERS_EQUAL(NULL, weelist_search (list, NULL));
 
159
    POINTERS_EQUAL(NULL, weelist_search (NULL, LIST_VALUE_TEST));
 
160
 
 
161
    POINTERS_EQUAL(NULL, weelist_search (list, "not found"));
 
162
    POINTERS_EQUAL(NULL, weelist_search (list, "TEST"));
 
163
 
 
164
    ptr_item = weelist_search (list, LIST_VALUE_TEST);
 
165
    CHECK(ptr_item);
 
166
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
167
 
 
168
    ptr_item = weelist_search (list, LIST_VALUE_XYZ);
 
169
    CHECK(ptr_item);
 
170
    STRCMP_EQUAL(LIST_VALUE_XYZ, ptr_item->data);
 
171
 
 
172
    ptr_item = weelist_search (list, LIST_VALUE_ZZZ);
 
173
    CHECK(ptr_item);
 
174
    STRCMP_EQUAL(LIST_VALUE_ZZZ, ptr_item->data);
 
175
 
 
176
    /* search the position of an element */
 
177
 
 
178
    LONGS_EQUAL(-1, weelist_search_pos (NULL, NULL));
 
179
    LONGS_EQUAL(-1, weelist_search_pos (list, NULL));
 
180
    LONGS_EQUAL(-1, weelist_search_pos (NULL, LIST_VALUE_TEST));
 
181
 
 
182
    LONGS_EQUAL(-1, weelist_search_pos (list, "not found"));
 
183
    LONGS_EQUAL(-1, weelist_search_pos (list, "TEST"));
 
184
 
 
185
    LONGS_EQUAL(0, weelist_search_pos (list, LIST_VALUE_TEST));
 
186
    LONGS_EQUAL(1, weelist_search_pos (list, LIST_VALUE_XYZ));
 
187
    LONGS_EQUAL(2, weelist_search_pos (list, LIST_VALUE_ZZZ));
 
188
 
 
189
    /* case-insensitive search of an element */
 
190
 
 
191
    POINTERS_EQUAL(NULL, weelist_casesearch (NULL, NULL));
 
192
    POINTERS_EQUAL(NULL, weelist_casesearch (list, NULL));
 
193
    POINTERS_EQUAL(NULL, weelist_casesearch (NULL, LIST_VALUE_TEST));
 
194
 
 
195
    POINTERS_EQUAL(NULL, weelist_casesearch (list, "not found"));
 
196
 
 
197
    ptr_item = weelist_casesearch (list, "TEST");
 
198
    CHECK(ptr_item);
 
199
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
200
 
 
201
    ptr_item = weelist_casesearch (list, LIST_VALUE_TEST);
 
202
    CHECK(ptr_item);
 
203
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
204
 
 
205
    ptr_item = weelist_casesearch (list, LIST_VALUE_XYZ);
 
206
    CHECK(ptr_item);
 
207
    STRCMP_EQUAL(LIST_VALUE_XYZ, ptr_item->data);
 
208
 
 
209
    ptr_item = weelist_casesearch (list, LIST_VALUE_ZZZ);
 
210
    CHECK(ptr_item);
 
211
    STRCMP_EQUAL(LIST_VALUE_ZZZ, ptr_item->data);
 
212
 
 
213
    /* case-insensitive search of an element position */
 
214
 
 
215
    LONGS_EQUAL(-1, weelist_casesearch_pos (NULL, NULL));
 
216
    LONGS_EQUAL(-1, weelist_casesearch_pos (list, NULL));
 
217
    LONGS_EQUAL(-1, weelist_casesearch_pos (NULL, LIST_VALUE_TEST));
 
218
 
 
219
    LONGS_EQUAL(-1, weelist_casesearch_pos (list, "not found"));
 
220
 
 
221
    LONGS_EQUAL(0, weelist_casesearch_pos (list, "TEST"));
 
222
    LONGS_EQUAL(0, weelist_casesearch_pos (list, LIST_VALUE_TEST));
 
223
    LONGS_EQUAL(1, weelist_casesearch_pos (list, LIST_VALUE_XYZ));
 
224
    LONGS_EQUAL(2, weelist_casesearch_pos (list, LIST_VALUE_ZZZ));
 
225
 
 
226
    /* free list */
 
227
    weelist_free (list);
64
228
}
65
229
 
66
230
/*
71
235
 
72
236
TEST(List, Get)
73
237
{
74
 
    /* TODO: write tests */
 
238
    struct t_weelist *list;
 
239
    struct t_weelist_item *ptr_item;
 
240
 
 
241
    list = test_list_new ();
 
242
 
 
243
    /* get an element by position */
 
244
 
 
245
    POINTERS_EQUAL(NULL, weelist_get (NULL, -1));
 
246
    POINTERS_EQUAL(NULL, weelist_get (list, -1));
 
247
    POINTERS_EQUAL(NULL, weelist_get (NULL, 0));
 
248
 
 
249
    POINTERS_EQUAL(NULL, weelist_get (list, 50));
 
250
 
 
251
    ptr_item = weelist_get (list, 0);
 
252
    CHECK(ptr_item);
 
253
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
254
 
 
255
    ptr_item = weelist_get (list, 1);
 
256
    CHECK(ptr_item);
 
257
    STRCMP_EQUAL(LIST_VALUE_XYZ, ptr_item->data);
 
258
 
 
259
    ptr_item = weelist_get (list, 2);
 
260
    CHECK(ptr_item);
 
261
    STRCMP_EQUAL(LIST_VALUE_ZZZ, ptr_item->data);
 
262
 
 
263
    /* get string value of an element */
 
264
 
 
265
    POINTERS_EQUAL(NULL, weelist_string (NULL));
 
266
 
 
267
    ptr_item = weelist_get(list, 0);
 
268
    STRCMP_EQUAL(LIST_VALUE_TEST, weelist_string (ptr_item));
 
269
 
 
270
    ptr_item = weelist_get(list, 1);
 
271
    STRCMP_EQUAL(LIST_VALUE_XYZ, weelist_string (ptr_item));
 
272
 
 
273
    ptr_item = weelist_get(list, 2);
 
274
    STRCMP_EQUAL(LIST_VALUE_ZZZ, weelist_string (ptr_item));
 
275
 
 
276
    /* free list */
 
277
    weelist_free (list);
75
278
}
76
279
 
77
280
/*
81
284
 
82
285
TEST(List, Set)
83
286
{
84
 
    /* TODO: write tests */
 
287
    struct t_weelist *list;
 
288
    struct t_weelist_item *ptr_item;
 
289
    const char *another_test = "another test";
 
290
 
 
291
    list = test_list_new ();
 
292
 
 
293
    ptr_item = weelist_get (list, 0);
 
294
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
295
 
 
296
    weelist_set (NULL, NULL);
 
297
    weelist_set (ptr_item, NULL);
 
298
    weelist_set (NULL, another_test);
 
299
 
 
300
    weelist_set (ptr_item, another_test);
 
301
    STRCMP_EQUAL(another_test, ptr_item->data);
 
302
 
 
303
    /* free list */
 
304
    weelist_free (list);
85
305
}
86
306
 
87
307
/*
92
312
 
93
313
TEST(List, Move)
94
314
{
95
 
    /* TODO: write tests */
 
315
    struct t_weelist *list;
 
316
    struct t_weelist_item *ptr_item;
 
317
 
 
318
    list = test_list_new ();
 
319
 
 
320
    /* get next item */
 
321
 
 
322
    ptr_item = weelist_get (list, 0);
 
323
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
324
    ptr_item = weelist_next (ptr_item);
 
325
    STRCMP_EQUAL(LIST_VALUE_XYZ, ptr_item->data);
 
326
    ptr_item = weelist_next (ptr_item);
 
327
    STRCMP_EQUAL(LIST_VALUE_ZZZ, ptr_item->data);
 
328
    ptr_item = weelist_next (ptr_item);
 
329
    POINTERS_EQUAL(NULL, ptr_item);
 
330
 
 
331
    /* get previous item */
 
332
 
 
333
    ptr_item = weelist_get(list, 2);
 
334
    STRCMP_EQUAL(LIST_VALUE_ZZZ, ptr_item->data);
 
335
    ptr_item = weelist_prev (ptr_item);
 
336
    STRCMP_EQUAL(LIST_VALUE_XYZ, ptr_item->data);
 
337
    ptr_item = weelist_prev (ptr_item);
 
338
    STRCMP_EQUAL(LIST_VALUE_TEST, ptr_item->data);
 
339
 
 
340
    /* free list */
 
341
    weelist_free (list);
96
342
}
97
343
 
98
344
/*
99
345
 * Tests functions:
100
346
 *   weelist_remove
101
347
 *   weelist_remove_all
102
 
 *   weelist_free
103
348
 */
104
349
 
105
350
TEST(List, Free)
106
351
{
107
 
    /* TODO: write tests */
 
352
    struct t_weelist *list;
 
353
    struct t_weelist_item *ptr_item;
 
354
 
 
355
    list = test_list_new ();
 
356
 
 
357
    /* remove one element */
 
358
 
 
359
    ptr_item = weelist_get(list, 1);
 
360
    STRCMP_EQUAL(LIST_VALUE_XYZ, ptr_item->data);
 
361
 
 
362
    weelist_remove (NULL, NULL);
 
363
    weelist_remove (list, NULL);
 
364
    weelist_remove (NULL, ptr_item);
 
365
 
 
366
    weelist_remove (list, ptr_item);
 
367
 
 
368
    ptr_item = weelist_get(list, 1);
 
369
    STRCMP_EQUAL(LIST_VALUE_ZZZ, ptr_item->data);
 
370
    ptr_item = weelist_get (list, 2);
 
371
    POINTERS_EQUAL(NULL, ptr_item);
 
372
 
 
373
    /* remove all elements */
 
374
 
 
375
    weelist_remove_all (list);
 
376
    LONGS_EQUAL(0, list->size);
 
377
    POINTERS_EQUAL(NULL, list->items);
 
378
    POINTERS_EQUAL(NULL, list->last_item);
 
379
 
 
380
    /* free list */
 
381
    weelist_free (list);
108
382
}
109
383
 
110
384
/*