efl

1
/* EINA - EFL data type library
2
 * Copyright (C) 2010 Sebastian Dransfeld
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library;
16
 * if not, see <http://www.gnu.org/licenses/>.
17
 */
18

19
#ifdef HAVE_CONFIG_H
20
# include "config.h"
21
#endif
22

23
#include <stdio.h>
24

25
#include <Eina.h>
26

27
#include "eina_suite.h"
28

29
EFL_START_TEST(eina_test_strbuf_simple)
30
{
31
   Eina_Strbuf *buf;
32
   char *txt;
33
   Eina_Slice ro_slice;
34
   Eina_Rw_Slice rw_slice;
35
#define TEST_TEXT \
36
  "This test should be so long that it is longer than the initial size of strbuf"
37

38
   buf = eina_strbuf_new();
39
   fail_if(!buf);
40

41
   eina_strbuf_append(buf, TEST_TEXT);
42
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT));
43
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
44
   eina_strbuf_append(buf, TEST_TEXT);
45
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT));
46
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
47
   txt = eina_strbuf_string_steal(buf);
48
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
49
   fail_if(strcmp(txt, TEST_TEXT TEST_TEXT));
50
   free(txt);
51
   fail_if(eina_strbuf_length_get(buf) != 0);
52
   fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT));
53
   eina_strbuf_append(buf, TEST_TEXT);
54
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
55
   eina_strbuf_reset(buf);
56
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
57
   fail_if(eina_strbuf_length_get(buf) != 0);
58
   fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT));
59

60
   ro_slice = eina_strbuf_slice_get(buf);
61
   fail_if(ro_slice.len != eina_strbuf_length_get(buf));
62
   fail_if(ro_slice.mem != eina_strbuf_string_get(buf));
63

64
   rw_slice = eina_strbuf_rw_slice_get(buf);
65
   fail_if(rw_slice.len != eina_strbuf_length_get(buf));
66
   fail_if(rw_slice.mem != eina_strbuf_string_get(buf));
67

68
   eina_strbuf_string_free(buf);
69
   fail_if(eina_strbuf_length_get(buf));
70
   eina_strbuf_append(buf, TEST_TEXT);
71
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT));
72

73
   eina_strbuf_free(buf);
74

75
#undef TEST_TEXT
76
}
77
EFL_END_TEST
78

79
EFL_START_TEST(eina_test_strbuf_manage_simple)
80
{
81
   Eina_Strbuf *buf;
82
   char *txt;
83
#define TEST_TEXT \
84
  "This test should be so long that it is longer than the initial size of strbuf"
85

86
   txt = strdup(TEST_TEXT);
87

88
   buf = eina_strbuf_manage_new(txt);
89
   fail_if(!buf);
90

91
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT));
92
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
93
   eina_strbuf_append(buf, TEST_TEXT);
94
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT));
95
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
96
   txt = eina_strbuf_string_steal(buf);
97
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
98
   fail_if(strcmp(txt, TEST_TEXT TEST_TEXT));
99
   free(txt);
100
   fail_if(eina_strbuf_length_get(buf) != 0);
101
   fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT));
102
   eina_strbuf_append(buf, TEST_TEXT);
103
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
104
   eina_strbuf_reset(buf);
105
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
106
   fail_if(eina_strbuf_length_get(buf) != 0);
107
   fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT));
108

109
   eina_strbuf_free(buf);
110

111
   buf = eina_strbuf_manage_read_only_new_length(TEST_TEXT, strlen(TEST_TEXT));
112
   fail_if(!buf);
113

114
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT));
115
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
116
   eina_strbuf_append(buf, TEST_TEXT);
117
   fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT));
118
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
119
   txt = eina_strbuf_string_steal(buf);
120
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
121
   fail_if(strcmp(txt, TEST_TEXT TEST_TEXT));
122
   free(txt);
123

124
#undef TEST_TEXT
125
}
126
EFL_END_TEST
127

128
EFL_START_TEST(eina_test_strbuf_remove)
129
{
130
   Eina_Strbuf *buf;
131

132
   buf = eina_strbuf_new();
133
   fail_if(!buf);
134

135
   eina_strbuf_append(buf, "123 456 789 abc");
136
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
137
   eina_strbuf_remove(buf, 0, 4);
138
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
139
   fail_if(strcmp(eina_strbuf_string_get(buf), "456 789 abc"));
140
   eina_strbuf_remove(buf, 8, 1000);
141
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
142
   fail_if(strcmp(eina_strbuf_string_get(buf), "456 789 "));
143
   eina_strbuf_remove(buf, 7, eina_strbuf_length_get(buf));
144
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
145
   fail_if(strcmp(eina_strbuf_string_get(buf), "456 789"));
146
   eina_strbuf_remove(buf, 2, 4);
147
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
148
   fail_if(strcmp(eina_strbuf_string_get(buf), "45789"));
149
   eina_strbuf_remove(buf, 4, 1);
150
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
151
   fail_if(strcmp(eina_strbuf_string_get(buf), "45789"));
152
   eina_strbuf_remove(buf, 0, eina_strbuf_length_get(buf));
153
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
154
   fail_if(strcmp(eina_strbuf_string_get(buf), ""));
155

156
#define TEST_TEXT \
157
  "This test should be so long that it is longer than the initial size of strbuf"
158
   eina_strbuf_append(buf, TEST_TEXT TEST_TEXT);
159
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
160
   eina_strbuf_remove(buf, 0, eina_strbuf_length_get(buf) - 1);
161
   fail_if(strcmp(eina_strbuf_string_get(buf), "f"));
162
#undef TEST_TEXT
163

164
   eina_strbuf_free(buf);
165
}
166
EFL_END_TEST
167

168
EFL_START_TEST(eina_test_strbuf_append)
169
{
170
   Eina_Strbuf *buf;
171
   Eina_Slice ro_slice = EINA_SLICE_STR_LITERAL("somethingELSE");
172

173
   ro_slice.len -= strlen("ELSE");
174

175
   buf = eina_strbuf_new();
176
   fail_if(!buf);
177

178
   eina_strbuf_append(buf, "abc");
179
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
180
   fail_if(strcmp(eina_strbuf_string_get(buf), "abc"));
181
   eina_strbuf_reset(buf);
182

183
   eina_strbuf_append_escaped(buf, "abc");
184
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
185
   fail_if(strcmp(eina_strbuf_string_get(buf), "abc"));
186
   eina_strbuf_reset(buf);
187

188
   eina_strbuf_append_escaped(buf, "abc '\\");
189
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
190
   fail_if(strcmp(eina_strbuf_string_get(buf), "abc\\ \\'\\\\"));
191
   eina_strbuf_reset(buf);
192

193
   eina_strbuf_append_n(buf, "abc", 2);
194
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
195
   fail_if(strcmp(eina_strbuf_string_get(buf), "ab"));
196
   eina_strbuf_reset(buf);
197

198
   eina_strbuf_append_char(buf, 'a');
199
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
200
   fail_if(strcmp(eina_strbuf_string_get(buf), "a"));
201
   eina_strbuf_reset(buf);
202

203
   eina_strbuf_append_length(buf, "something", strlen("something"));
204
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
205
   fail_if(strcmp(eina_strbuf_string_get(buf), "something"));
206
   eina_strbuf_reset(buf);
207

208
   eina_strbuf_append_slice(buf, ro_slice);
209
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
210
   fail_if(strcmp(eina_strbuf_string_get(buf), "something"));
211
   eina_strbuf_reset(buf);
212

213
   eina_strbuf_free(buf);
214
}
215
EFL_END_TEST
216

217
EFL_START_TEST(eina_test_strbuf_insert)
218
{
219
   Eina_Strbuf *buf;
220
   Eina_Slice ro_slice = EINA_SLICE_STR_LITERAL("EINA");
221

222
   ro_slice.len = 2;
223

224
   buf = eina_strbuf_new();
225
   fail_if(!buf);
226

227
   eina_strbuf_insert(buf, "abc", 10);
228
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
229
   fail_if(strcmp(eina_strbuf_string_get(buf), "abc"));
230

231
   eina_strbuf_insert(buf, "123", 0);
232
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
233
   fail_if(strcmp(eina_strbuf_string_get(buf), "123abc"));
234

235
   eina_strbuf_insert(buf, "xyz", eina_strbuf_length_get(buf));
236
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
237
   fail_if(strcmp(eina_strbuf_string_get(buf), "123abcxyz"));
238

239
   eina_strbuf_insert(buf, "xyz", 1);
240
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
241
   fail_if(strcmp(eina_strbuf_string_get(buf), "1xyz23abcxyz"));
242

243
   eina_strbuf_insert_n(buf, "ABCDEF", 2, 1);
244
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
245
   fail_if(strcmp(eina_strbuf_string_get(buf), "1ABxyz23abcxyz"));
246

247
   eina_strbuf_insert_slice(buf, ro_slice, 3);
248
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
249
   fail_if(strcmp(eina_strbuf_string_get(buf), "1ABEIxyz23abcxyz"));
250

251
   eina_strbuf_insert_escaped(buf, "678", 3);
252
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
253
   fail_if(strncmp(eina_strbuf_string_get(buf) + 3, "678", 3));
254

255
   eina_strbuf_insert_escaped(buf, "089 '\\", 9);
256
   fail_if(strlen(eina_strbuf_string_get(
257
                    buf)) != eina_strbuf_length_get(buf));
258
   fail_if(strncmp(eina_strbuf_string_get(buf) + 9,
259
                   "089\\ \\'\\\\",
260
                   strlen("089\\ \\'\\\\")));
261
   eina_strbuf_reset(buf);
262

263
   eina_strbuf_free(buf);
264
}
265
EFL_END_TEST
266

267
EFL_START_TEST(eina_test_strbuf_replace)
268
{
269
   Eina_Strbuf *buf;
270

271
   buf = eina_strbuf_new();
272
   fail_if(!buf);
273

274
   eina_strbuf_append(buf, "aaa");
275
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
276
   fail_if(strcmp(eina_strbuf_string_get(buf), "aaa"));
277

278
   fail_if(!eina_strbuf_replace(buf, "a", "b", 1));
279
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
280
   fail_if(strcmp(eina_strbuf_string_get(buf), "baa"));
281

282
   fail_if(eina_strbuf_replace_all(buf, "a", "b") != 2);
283
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
284
   fail_if(strcmp(eina_strbuf_string_get(buf), "bbb"));
285

286
   fail_if(!eina_strbuf_replace(buf, "b", "cc", 2));
287
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
288
   fail_if(strcmp(eina_strbuf_string_get(buf), "bccb"));
289

290
   fail_if(eina_strbuf_replace_all(buf, "c", "aa") != 2);
291
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
292
   fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab"));
293

294
   fail_if(eina_strbuf_replace(buf, "c", "aa", 0));
295
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
296
   fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab"));
297

298
   fail_if(eina_strbuf_replace(buf, "c", "aa", 2));
299
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
300
   fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab"));
301

302
   fail_if(eina_strbuf_replace_all(buf, "c", "aa") != 0);
303
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
304
   fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab"));
305

306
   fail_if(eina_strbuf_replace_last(buf, "a", "x") == 0);
307
   fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf));
308
   fail_if(strcmp(eina_strbuf_string_get(buf), "baaaxb"));
309

310
   fail_if(eina_strbuf_replace_first(buf, "a", "b") == 0);
311
   fail_if(strcmp(eina_strbuf_string_get(buf), "bbaaxb"));
312

313
   eina_strbuf_free(buf);
314

315
   buf = eina_strbuf_manage_read_only_new_length("baaaab",6);
316
   fail_if(!buf);
317
   fail_if(eina_strbuf_replace_first(buf, "a", "b") == 0);
318
   fail_if(strcmp(eina_strbuf_string_get(buf), "bbaaab"));
319

320
   eina_strbuf_free(buf);
321
}
322
EFL_END_TEST
323

324
EFL_START_TEST(eina_test_strbuf_realloc)
325
{
326
   Eina_Strbuf *buf;
327
   char pattern[1024 * 16];
328
   unsigned int i;
329
   size_t sz;
330

331
   for (i = 0; i < sizeof(pattern) - 1; i++)
332
     pattern[i] = 'a' + (i % 26);
333
   pattern[i] = '\0';
334

335
   buf = eina_strbuf_new();
336
   fail_if(!buf);
337

338
   sz = 0;
339

340
   eina_strbuf_append_length(buf, pattern, 1);
341
   fail_if(eina_strbuf_length_get(buf) != sz + 1);
342
   fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 1));
343
   sz += 1;
344

345
   eina_strbuf_append_length(buf, pattern, 32);
346
   fail_if(eina_strbuf_length_get(buf) != sz + 32);
347
   fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 32));
348
   sz += 32;
349

350
   eina_strbuf_append_length(buf, pattern, 64);
351
   fail_if(eina_strbuf_length_get(buf) != sz + 64);
352
   fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 64));
353
   sz += 64;
354

355
   eina_strbuf_append_length(buf, pattern, 128);
356
   fail_if(eina_strbuf_length_get(buf) != sz + 128);
357
   fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 128));
358
   sz += 128;
359

360
   eina_strbuf_append_length(buf, pattern, 4096);
361
   fail_if(eina_strbuf_length_get(buf) != sz + 4096);
362
   fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 4096));
363
   sz += 4096;
364

365
   eina_strbuf_append_length(buf, pattern, sizeof(pattern) - 1);
366
   fail_if(eina_strbuf_length_get(buf) != sz + sizeof(pattern) - 1);
367
   fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, sizeof(pattern) -
368
                  1));
369
   sz += sizeof(pattern) - 1;
370

371
   eina_strbuf_remove(buf, 1024, 1024 + 1234);
372
   fail_if(eina_strbuf_length_get(buf) != sz - 1234);
373
   sz -= 1234;
374

375
   eina_strbuf_remove(buf, 0, 0 + 8192);
376
   fail_if(eina_strbuf_length_get(buf) != sz - 8192);
377
   sz -= 8192;
378

379
   eina_strbuf_remove(buf, 0, 0 + 32);
380
   fail_if(eina_strbuf_length_get(buf) != sz - 32);
381

382
   eina_strbuf_free(buf);
383
}
384
EFL_END_TEST
385

386
EFL_START_TEST(eina_test_strbuf_append_realloc)
387
{
388
   Eina_Strbuf *buf;
389
   const size_t runs = 3 * 10;
390
   const char target_pattern[] = "stringstrsstr";
391
   const char *str;
392
   size_t i, target_pattern_size;
393

394
   buf = eina_strbuf_new();
395
   fail_if(!buf);
396

397
   for (i = 0; i < runs; i++)
398
     {
399
        ck_assert_int_ne(eina_strbuf_append(buf, "string"), 0); //6
400
        ck_assert_int_ne(eina_strbuf_append_n(buf, "string", 3), 0); //3
401
        ck_assert_int_ne(eina_strbuf_append_char(buf, 's'), 0); //1
402
        ck_assert_int_ne(eina_strbuf_append_length(buf, "string", 3), 0); //3
403
     }
404

405
   target_pattern_size = strlen(target_pattern);
406
   ck_assert_int_eq(eina_strbuf_length_get(buf), runs * target_pattern_size);
407

408
   str = eina_strbuf_string_get(buf);
409
   ck_assert_ptr_ne(str, NULL);
410
   for (i = 0; i < runs; i++, str += target_pattern_size)
411
     ck_assert_int_eq(memcmp(str, target_pattern, target_pattern_size), 0);
412

413
   eina_strbuf_free(buf);
414
}
415
EFL_END_TEST
416

417
EFL_START_TEST(eina_test_strbuf_prepend_realloc)
418
{
419
   Eina_Strbuf *buf;
420
   const size_t runs = 3 * 10;
421
   const char target_pattern[] = "strsstrstring";
422
   const char *str;
423
   size_t i, target_pattern_size;
424

425
   buf = eina_strbuf_new();
426
   fail_if(!buf);
427

428
   for (i = 0; i < runs; i++)
429
     {
430
        ck_assert_int_ne(eina_strbuf_prepend(buf, "string"), 0); //6
431
        ck_assert_int_ne(eina_strbuf_prepend_n(buf, "string", 3), 0); //3
432
        ck_assert_int_ne(eina_strbuf_prepend_char(buf, 's'), 0); //1
433
        ck_assert_int_ne(eina_strbuf_prepend_length(buf, "string", 3), 0); //3
434
     }
435

436
   target_pattern_size = strlen(target_pattern);
437
   ck_assert_int_eq(eina_strbuf_length_get(buf), runs * target_pattern_size);
438

439
   str = eina_strbuf_string_get(buf);
440
   ck_assert_ptr_ne(str, NULL);
441
   for (i = 0; i < runs; i++, str += target_pattern_size)
442
     ck_assert_int_eq(memcmp(str, target_pattern, target_pattern_size), 0);
443

444
   eina_strbuf_free(buf);
445
}
446
EFL_END_TEST
447

448
EFL_START_TEST(eina_test_strbuf_trim)
449
{
450
   Eina_Strbuf *buf;
451
   const char *str;
452

453
   buf = eina_strbuf_new();
454
   fail_unless(buf != NULL);
455

456
   eina_strbuf_append(buf, "  string     ");
457
   eina_strbuf_trim(buf);
458
   str = eina_strbuf_string_get(buf);
459
   fail_if(str == NULL || strcmp(str, "string") != 0);
460
   eina_strbuf_reset(buf);
461

462
   eina_strbuf_append(buf, "  string     ");
463
   eina_strbuf_ltrim(buf);
464
   str = eina_strbuf_string_get(buf);
465
   fail_if(str == NULL || strcmp(str, "string     ") != 0);
466
   eina_strbuf_rtrim(buf);
467
   str = eina_strbuf_string_get(buf);
468
   fail_if(str == NULL || strcmp(str, "string") != 0);
469
   eina_strbuf_reset(buf);
470

471
   eina_strbuf_append(buf, "             ");
472
   eina_strbuf_trim(buf);
473
   str = eina_strbuf_string_get(buf);
474
   fail_if(str == NULL || strcmp(str, "") != 0);
475
   eina_strbuf_reset(buf);
476

477
   eina_strbuf_append(buf, "             ");
478
   eina_strbuf_rtrim(buf);
479
   str = eina_strbuf_string_get(buf);
480
   fail_if(str == NULL || strcmp(str, "") != 0);
481
   eina_strbuf_reset(buf);
482

483
   eina_strbuf_append(buf, "             ");
484
   eina_strbuf_ltrim(buf);
485
   str = eina_strbuf_string_get(buf);
486
   fail_if(str == NULL || strcmp(str, "") != 0);
487
   eina_strbuf_reset(buf);
488

489
   eina_strbuf_free(buf);
490
}
491
EFL_END_TEST
492

493
EFL_START_TEST(eina_test_strbuf_tolower)
494
{
495
   Eina_Strbuf *buf;
496
   const char *str;
497

498
   buf = eina_strbuf_new();
499
   fail_unless(buf != NULL);
500

501
   eina_strbuf_append(buf, "UPPER");
502
   eina_strbuf_tolower(buf);
503
   str = eina_strbuf_string_get(buf);
504
   fail_unless(str && !strcmp(str, "upper"));
505

506
   eina_strbuf_tolower(buf);
507
   str = eina_strbuf_string_get(buf);
508
   fail_unless(str && !strcmp(str, "upper"));
509

510
   eina_strbuf_append(buf, "1@ ");
511
   eina_strbuf_tolower(buf);
512
   str = eina_strbuf_string_get(buf);
513
   fail_unless(str && !strcmp(str, "upper1@ "));
514

515
   eina_strbuf_free(buf);
516
}
517
EFL_END_TEST
518

519
EFL_START_TEST(eina_test_strbuf_substr_get)
520
{
521
   Eina_Strbuf *buf, *substr;
522
   const char *str;
523

524
   buf = eina_strbuf_new();
525
   fail_unless(buf != NULL);
526

527
   eina_strbuf_append(buf, "string");
528
   substr = eina_strbuf_substr_get(buf, 2, 3);
529
   str = eina_strbuf_string_get(substr);
530
   fail_unless(str && !strcmp(str, "rin"));
531
   eina_strbuf_free(substr);
532

533
   substr = eina_strbuf_substr_get(buf, 0, 6);
534
   str = eina_strbuf_string_get(substr);
535
   fail_unless(str && !strcmp(str, "string"));
536
   eina_strbuf_free(substr);
537

538
   substr = eina_strbuf_substr_get(buf, 6, 0);
539
   str = eina_strbuf_string_get(substr);
540
   fail_unless(str && !strcmp(str, ""));
541
   eina_strbuf_free(substr);
542

543
   substr = eina_strbuf_substr_get(buf, 6, 1);
544
   str = eina_strbuf_string_get(substr);
545
   fail_if(str);
546
   eina_strbuf_free(substr);
547

548
   substr = eina_strbuf_substr_get(buf, 0, 7);
549
   str = eina_strbuf_string_get(substr);
550
   fail_if(str);
551
   eina_strbuf_free(substr);
552

553
   substr = eina_strbuf_substr_get(NULL, 0, 7);
554
   fail_if(substr);
555

556
   eina_strbuf_free(buf);
557
}
558
EFL_END_TEST
559

560
static const char *
561
test_prepend_vprintf(Eina_Strbuf *buf, char *fmt, va_list ap)
562
{
563
   const char *str;
564

565
   eina_strbuf_prepend_vprintf(buf, fmt, ap);
566
   str = eina_strbuf_string_get(buf);
567
   return str;
568
}
569

570
static const char *
571
test_prepend(Eina_Strbuf *buf, ...)
572
{
573
   const char *str;
574

575
   va_list ap;
576

577
   va_start(ap, buf);
578
   str = test_prepend_vprintf(buf, "%s %s %s %s", ap);
579
   va_end(ap);
580
   return str;
581
}
582

583
EFL_START_TEST(eina_test_strbuf_prepend_print)
584
{
585
   Eina_Bool ret;
586
   Eina_Strbuf *buf;
587
   const char *str;
588

589
   buf = eina_strbuf_new();
590
   fail_unless(buf != NULL);
591

592
   ret = eina_strbuf_prepend_printf(buf, "%s", "string");
593
   fail_if(ret != EINA_TRUE);
594
   str = eina_strbuf_string_get(buf);
595
   fail_if(str == NULL || strcmp(str, "string") != 0);
596

597
   ret = eina_strbuf_prepend_printf(buf, "This is %d ", 1);
598
   fail_if(ret != EINA_TRUE);
599
   str = eina_strbuf_string_get(buf);
600
   fail_if(str == NULL || strcmp(str, "This is 1 string") != 0);
601

602
   ret = eina_strbuf_prepend_printf(buf, "%s   ", "hello");
603
   fail_if(ret != EINA_TRUE);
604
   str = eina_strbuf_string_get(buf);
605
   fail_if(str == NULL || strcmp(str, "hello   This is 1 string") != 0);
606
   eina_strbuf_reset(buf);
607

608
   str = test_prepend(buf, "This", "is", "test", "string");
609
   fail_if(str == NULL || strcmp(str, "This is test string") != 0);
610

611
   eina_strbuf_free(buf);
612
}
613
EFL_END_TEST
614

615
EFL_START_TEST(eina_test_strbuf_release_test)
616
{
617
   Eina_Strbuf *buf;
618
   char *string;
619

620
   buf = eina_strbuf_new();
621
   ck_assert_ptr_ne(buf, NULL);
622
   eina_strbuf_append(buf, "strbuf_release_test");
623

624
   string = eina_strbuf_release(buf);
625
   ck_assert_str_eq(string, "strbuf_release_test");
626
   free(string);
627
}
628
EFL_END_TEST
629

630
EFL_START_TEST(eina_test_strbuf_strftime_test)
631
{
632
   Eina_Strbuf *buf;
633
   time_t curr_time;
634
   struct tm *info;
635
   char cbuf[32];
636
   const char *str;
637

638
   curr_time = time(NULL);
639
   info = localtime(&curr_time);
640

641
   strftime(cbuf, 32, "%I:%M%p", info);
642

643
   buf = eina_strbuf_new();
644
   eina_strbuf_append_strftime(buf, "%I:%M%p", info);
645
   str = eina_strbuf_string_get(buf);
646
   fail_if(str == NULL || strcmp(str, cbuf) != 0);
647
   eina_strbuf_reset(buf);
648

649
   eina_strbuf_append(buf, "Hours: Minutes");
650
   eina_strbuf_prepend_strftime(buf, "%I ", info);
651
   eina_strbuf_insert_strftime(buf, "%M ", info, 10);
652
   strftime(cbuf, 32, "%I Hours: %M Minutes", info);
653
   str = eina_strbuf_string_get(buf);
654
   fail_if(str == NULL || strcmp(str, cbuf) != 0);
655

656
   eina_strbuf_free(buf);
657
}
658
EFL_END_TEST
659

660
void
661
eina_test_strbuf(TCase *tc)
662
{
663
   tcase_add_test(tc, eina_test_strbuf_simple);
664
   tcase_add_test(tc, eina_test_strbuf_remove);
665
   tcase_add_test(tc, eina_test_strbuf_append);
666
   tcase_add_test(tc, eina_test_strbuf_insert);
667
   tcase_add_test(tc, eina_test_strbuf_replace);
668
   tcase_add_test(tc, eina_test_strbuf_realloc);
669
   tcase_add_test(tc, eina_test_strbuf_append_realloc);
670
   tcase_add_test(tc, eina_test_strbuf_prepend_realloc);
671
   tcase_add_test(tc, eina_test_strbuf_manage_simple);
672
   tcase_add_test(tc, eina_test_strbuf_trim);
673
   tcase_add_test(tc, eina_test_strbuf_tolower);
674
   tcase_add_test(tc, eina_test_strbuf_substr_get);
675
   tcase_add_test(tc, eina_test_strbuf_prepend_print);
676
   tcase_add_test(tc, eina_test_strbuf_release_test);
677
   tcase_add_test(tc, eina_test_strbuf_strftime_test);
678
}
679

680