D-Bus  1.12.2
dbus-string-util.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-string-util.c Would be in dbus-string.c, but not used in libdbus
3  *
4  * Copyright (C) 2002, 2003, 2004, 2005 Red Hat, Inc.
5  * Copyright (C) 2006 Ralf Habacker <ralf.habacker@freenet.de>
6  *
7  * Licensed under the Academic Free License version 2.1
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  */
24 
25 #include <config.h>
26 #include "dbus-internals.h"
27 #include "dbus-string.h"
28 #define DBUS_CAN_USE_DBUS_STRING_PRIVATE 1
29 #include "dbus-string-private.h"
30 
47  const char *c_str)
48 {
49  const unsigned char *ap;
50  const unsigned char *bp;
51  const unsigned char *a_end;
52  unsigned long c_str_len;
53  const DBusRealString *real_a = (const DBusRealString*) a;
55  _dbus_assert (c_str != NULL);
56 
57  c_str_len = strlen (c_str);
58  if (((unsigned long)real_a->len) < c_str_len)
59  return FALSE;
60 
61  ap = real_a->str + (real_a->len - c_str_len);
62  bp = (const unsigned char*) c_str;
63  a_end = real_a->str + real_a->len;
64  while (ap != a_end)
65  {
66  if (*ap != *bp)
67  return FALSE;
68 
69  ++ap;
70  ++bp;
71  }
72 
73  _dbus_assert (*ap == '\0');
74  _dbus_assert (*bp == '\0');
75 
76  return TRUE;
77 }
78 
91  int start,
92  unsigned char byte,
93  int *found)
94 {
95  int i;
97  _dbus_assert (start <= real->len);
98  _dbus_assert (start >= 0);
99  _dbus_assert (found != NULL);
100 
101  i = start - 1;
102  while (i >= 0)
103  {
104  if (real->str[i] == byte)
105  break;
106 
107  --i;
108  }
109 
110  if (found)
111  *found = i;
112 
113  return i >= 0;
114 }
115 
118 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
119 #include "dbus-test.h"
120 #include <stdio.h>
121 
122 static void
123 test_hex_roundtrip (const char *data,
124  int len)
125 {
126  DBusString orig;
127  DBusString encoded;
128  DBusString decoded;
129  int end;
130 
131  if (len < 0)
132  len = strlen (data);
133 
134  if (!_dbus_string_init (&orig))
135  _dbus_assert_not_reached ("could not init string");
136 
137  if (!_dbus_string_init (&encoded))
138  _dbus_assert_not_reached ("could not init string");
139 
140  if (!_dbus_string_init (&decoded))
141  _dbus_assert_not_reached ("could not init string");
142 
143  if (!_dbus_string_append_len (&orig, data, len))
144  _dbus_assert_not_reached ("couldn't append orig data");
145 
146  if (!_dbus_string_hex_encode (&orig, 0, &encoded, 0))
147  _dbus_assert_not_reached ("could not encode");
148 
149  if (!_dbus_string_hex_decode (&encoded, 0, &end, &decoded, 0))
150  _dbus_assert_not_reached ("could not decode");
151 
152  _dbus_assert (_dbus_string_get_length (&encoded) == end);
153 
154  if (!_dbus_string_equal (&orig, &decoded))
155  {
156  const char *s;
157 
158  printf ("Original string %d bytes encoded %d bytes decoded %d bytes\n",
159  _dbus_string_get_length (&orig),
160  _dbus_string_get_length (&encoded),
161  _dbus_string_get_length (&decoded));
162  printf ("Original: %s\n", data);
163  s = _dbus_string_get_const_data (&decoded);
164  printf ("Decoded: %s\n", s);
165  _dbus_assert_not_reached ("original string not the same as string decoded from hex");
166  }
167 
168  _dbus_string_free (&orig);
169  _dbus_string_free (&encoded);
170  _dbus_string_free (&decoded);
171 }
172 
173 typedef void (* TestRoundtripFunc) (const char *data,
174  int len);
175 static void
176 test_roundtrips (TestRoundtripFunc func)
177 {
178  (* func) ("Hello this is a string\n", -1);
179  (* func) ("Hello this is a string\n1", -1);
180  (* func) ("Hello this is a string\n12", -1);
181  (* func) ("Hello this is a string\n123", -1);
182  (* func) ("Hello this is a string\n1234", -1);
183  (* func) ("Hello this is a string\n12345", -1);
184  (* func) ("", 0);
185  (* func) ("1", 1);
186  (* func) ("12", 2);
187  (* func) ("123", 3);
188  (* func) ("1234", 4);
189  (* func) ("12345", 5);
190  (* func) ("", 1);
191  (* func) ("1", 2);
192  (* func) ("12", 3);
193  (* func) ("123", 4);
194  (* func) ("1234", 5);
195  (* func) ("12345", 6);
196  {
197  unsigned char buf[512];
198  int i;
199 
200  i = 0;
201  while (i < _DBUS_N_ELEMENTS (buf))
202  {
203  buf[i] = (i & 0xff);
204  ++i;
205  }
206  i = 0;
207  while (i < _DBUS_N_ELEMENTS (buf))
208  {
209  (* func) ((const char *) buf, i);
210  ++i;
211  }
212  }
213 }
214 
226 _dbus_string_test (void)
227 {
228  DBusString str;
229  DBusString other;
230  int i, a, end;
231  long v;
232  int lens[] = { 0, 1, 2, 3, 4, 5, 10, 16, 17, 18, 25, 31, 32, 33, 34, 35, 63, 64, 65, 66, 67, 68, 69, 70, 71, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136 };
233  char *s;
234 
235  /* Test shortening and setting length */
236  i = 0;
237  while (i < _DBUS_N_ELEMENTS (lens))
238  {
239  int j;
240 
241  if (!_dbus_string_init (&str))
242  _dbus_assert_not_reached ("failed to init string");
243 
244  if (!_dbus_string_set_length (&str, lens[i]))
245  _dbus_assert_not_reached ("failed to set string length");
246 
247  j = lens[i];
248  while (j > 0)
249  {
250  _dbus_assert (_dbus_string_get_length (&str) == j);
251  if (j > 0)
252  {
253  _dbus_string_shorten (&str, 1);
254  _dbus_assert (_dbus_string_get_length (&str) == (j - 1));
255  }
256  --j;
257  }
258 
259  _dbus_string_free (&str);
260 
261  ++i;
262  }
263 
264  /* Test equality */
265  if (!_dbus_string_init (&str))
266  _dbus_assert_not_reached ("oom");
267 
268  if (!_dbus_string_append (&str, "Hello World"))
269  _dbus_assert_not_reached ("oom");
270 
271  _dbus_string_init_const (&other, "H");
272  _dbus_assert (_dbus_string_equal_substring (&str, 0, 1, &other, 0));
273  _dbus_assert (_dbus_string_equal_substring (&str, 1, 0, &other, 1));
274  _dbus_string_init_const (&other, "Hello");
275  _dbus_assert (_dbus_string_equal_substring (&str, 0, 5, &other, 0));
276  _dbus_assert (_dbus_string_equal_substring (&str, 1, 4, &other, 1));
277  _dbus_assert (_dbus_string_equal_substring (&str, 2, 3, &other, 2));
278  _dbus_assert (_dbus_string_equal_substring (&str, 3, 2, &other, 3));
279  _dbus_assert (_dbus_string_equal_substring (&str, 4, 1, &other, 4));
280  _dbus_assert (_dbus_string_equal_substring (&str, 5, 0, &other, 5));
281 
282  _dbus_assert (_dbus_string_equal_substring (&other, 0, 5, &str, 0));
283  _dbus_assert (_dbus_string_equal_substring (&other, 1, 4, &str, 1));
284  _dbus_assert (_dbus_string_equal_substring (&other, 2, 3, &str, 2));
285  _dbus_assert (_dbus_string_equal_substring (&other, 3, 2, &str, 3));
286  _dbus_assert (_dbus_string_equal_substring (&other, 4, 1, &str, 4));
287  _dbus_assert (_dbus_string_equal_substring (&other, 5, 0, &str, 5));
288 
289 
290  _dbus_string_init_const (&other, "World");
291  _dbus_assert (_dbus_string_equal_substring (&str, 6, 5, &other, 0));
292  _dbus_assert (_dbus_string_equal_substring (&str, 7, 4, &other, 1));
293  _dbus_assert (_dbus_string_equal_substring (&str, 8, 3, &other, 2));
294  _dbus_assert (_dbus_string_equal_substring (&str, 9, 2, &other, 3));
295  _dbus_assert (_dbus_string_equal_substring (&str, 10, 1, &other, 4));
296  _dbus_assert (_dbus_string_equal_substring (&str, 11, 0, &other, 5));
297 
298  _dbus_assert (_dbus_string_equal_substring (&other, 0, 5, &str, 6));
299  _dbus_assert (_dbus_string_equal_substring (&other, 1, 4, &str, 7));
300  _dbus_assert (_dbus_string_equal_substring (&other, 2, 3, &str, 8));
301  _dbus_assert (_dbus_string_equal_substring (&other, 3, 2, &str, 9));
302  _dbus_assert (_dbus_string_equal_substring (&other, 4, 1, &str, 10));
303  _dbus_assert (_dbus_string_equal_substring (&other, 5, 0, &str, 11));
304 
305  _dbus_string_free (&str);
306 
307  /* Test appending data */
308  if (!_dbus_string_init (&str))
309  _dbus_assert_not_reached ("failed to init string");
310 
311  i = 0;
312  while (i < 10)
313  {
314  if (!_dbus_string_append (&str, "a"))
315  _dbus_assert_not_reached ("failed to append string to string");
316 
317  _dbus_assert (_dbus_string_get_length (&str) == i * 2 + 1);
318 
319  if (!_dbus_string_append_byte (&str, 'b'))
320  _dbus_assert_not_reached ("failed to append byte to string");
321 
322  _dbus_assert (_dbus_string_get_length (&str) == i * 2 + 2);
323 
324  ++i;
325  }
326 
327  _dbus_string_free (&str);
328 
329  /* Check steal_data */
330 
331  if (!_dbus_string_init (&str))
332  _dbus_assert_not_reached ("failed to init string");
333 
334  if (!_dbus_string_append (&str, "Hello World"))
335  _dbus_assert_not_reached ("could not append to string");
336 
337  i = _dbus_string_get_length (&str);
338 
339  if (!_dbus_string_steal_data (&str, &s))
340  _dbus_assert_not_reached ("failed to steal data");
341 
342  _dbus_assert (_dbus_string_get_length (&str) == 0);
343  _dbus_assert (((int)strlen (s)) == i);
344 
345  dbus_free (s);
346 
347  /* Check move */
348 
349  if (!_dbus_string_append (&str, "Hello World"))
350  _dbus_assert_not_reached ("could not append to string");
351 
352  i = _dbus_string_get_length (&str);
353 
354  if (!_dbus_string_init (&other))
355  _dbus_assert_not_reached ("could not init string");
356 
357  if (!_dbus_string_move (&str, 0, &other, 0))
358  _dbus_assert_not_reached ("could not move");
359 
360  _dbus_assert (_dbus_string_get_length (&str) == 0);
361  _dbus_assert (_dbus_string_get_length (&other) == i);
362 
363  if (!_dbus_string_append (&str, "Hello World"))
364  _dbus_assert_not_reached ("could not append to string");
365 
366  if (!_dbus_string_move (&str, 0, &other, _dbus_string_get_length (&other)))
367  _dbus_assert_not_reached ("could not move");
368 
369  _dbus_assert (_dbus_string_get_length (&str) == 0);
370  _dbus_assert (_dbus_string_get_length (&other) == i * 2);
371 
372  if (!_dbus_string_append (&str, "Hello World"))
373  _dbus_assert_not_reached ("could not append to string");
374 
375  if (!_dbus_string_move (&str, 0, &other, _dbus_string_get_length (&other) / 2))
376  _dbus_assert_not_reached ("could not move");
377 
378  _dbus_assert (_dbus_string_get_length (&str) == 0);
379  _dbus_assert (_dbus_string_get_length (&other) == i * 3);
380 
381  _dbus_string_free (&other);
382 
383  /* Check copy */
384 
385  if (!_dbus_string_append (&str, "Hello World"))
386  _dbus_assert_not_reached ("could not append to string");
387 
388  i = _dbus_string_get_length (&str);
389 
390  if (!_dbus_string_init (&other))
391  _dbus_assert_not_reached ("could not init string");
392 
393  if (!_dbus_string_copy (&str, 0, &other, 0))
394  _dbus_assert_not_reached ("could not copy");
395 
396  _dbus_assert (_dbus_string_get_length (&str) == i);
397  _dbus_assert (_dbus_string_get_length (&other) == i);
398 
399  if (!_dbus_string_copy (&str, 0, &other, _dbus_string_get_length (&other)))
400  _dbus_assert_not_reached ("could not copy");
401 
402  _dbus_assert (_dbus_string_get_length (&str) == i);
403  _dbus_assert (_dbus_string_get_length (&other) == i * 2);
405  "Hello WorldHello World"));
406 
407  if (!_dbus_string_copy (&str, 0, &other, _dbus_string_get_length (&other) / 2))
408  _dbus_assert_not_reached ("could not copy");
409 
410  _dbus_assert (_dbus_string_get_length (&str) == i);
411  _dbus_assert (_dbus_string_get_length (&other) == i * 3);
413  "Hello WorldHello WorldHello World"));
414 
415  _dbus_string_free (&str);
416  _dbus_string_free (&other);
417 
418  /* Check replace */
419 
420  if (!_dbus_string_init (&str))
421  _dbus_assert_not_reached ("failed to init string");
422 
423  if (!_dbus_string_append (&str, "Hello World"))
424  _dbus_assert_not_reached ("could not append to string");
425 
426  i = _dbus_string_get_length (&str);
427 
428  if (!_dbus_string_init (&other))
429  _dbus_assert_not_reached ("could not init string");
430 
431  if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
432  &other, 0, _dbus_string_get_length (&other)))
433  _dbus_assert_not_reached ("could not replace");
434 
435  _dbus_assert (_dbus_string_get_length (&str) == i);
436  _dbus_assert (_dbus_string_get_length (&other) == i);
437  _dbus_assert (_dbus_string_equal_c_str (&other, "Hello World"));
438 
439  if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
440  &other, 5, 1))
441  _dbus_assert_not_reached ("could not replace center space");
442 
443  _dbus_assert (_dbus_string_get_length (&str) == i);
444  _dbus_assert (_dbus_string_get_length (&other) == i * 2 - 1);
446  "HelloHello WorldWorld"));
447 
448 
449  if (!_dbus_string_replace_len (&str, 1, 1,
450  &other,
451  _dbus_string_get_length (&other) - 1,
452  1))
453  _dbus_assert_not_reached ("could not replace end character");
454 
455  _dbus_assert (_dbus_string_get_length (&str) == i);
456  _dbus_assert (_dbus_string_get_length (&other) == i * 2 - 1);
458  "HelloHello WorldWorle"));
459 
460  _dbus_string_free (&str);
461  _dbus_string_free (&other);
462 
463  /* Different tests are provided because different behaviours are
464  * implemented in _dbus_string_replace_len() in function of replacing and
465  * replaced lengths
466  */
467 
468  if (!_dbus_string_init (&str))
469  _dbus_assert_not_reached ("failed to init string");
470 
471  if (!_dbus_string_append (&str, "Hello World"))
472  _dbus_assert_not_reached ("could not append to string");
473 
474  i = _dbus_string_get_length (&str);
475 
476  if (!_dbus_string_init (&other))
477  _dbus_assert_not_reached ("could not init string");
478 
479  if (!_dbus_string_append (&other, "Foo String"))
480  _dbus_assert_not_reached ("could not append to string");
481 
482  a = _dbus_string_get_length (&other);
483 
484  if (!_dbus_string_replace_len (&str, 0, 6,
485  &other, 4, 0))
486  _dbus_assert_not_reached ("could not replace 0 length");
487 
488  _dbus_assert (_dbus_string_get_length (&str) == i);
489  _dbus_assert (_dbus_string_get_length (&other) == a + 6);
491  "Foo Hello String"));
492 
493  if (!_dbus_string_replace_len (&str, 5, 6,
494  &other,
495  _dbus_string_get_length (&other),
496  0))
497  _dbus_assert_not_reached ("could not replace at the end");
498 
499  _dbus_assert (_dbus_string_get_length (&str) == i);
500  _dbus_assert (_dbus_string_get_length (&other) == a + 6 + 6);
502  "Foo Hello String World"));
503 
504  if (!_dbus_string_replace_len (&str, 0, 5,
505  &other,
506  _dbus_string_get_length (&other) - 5,
507  5))
508  _dbus_assert_not_reached ("could not replace same length");
509 
510  _dbus_assert (_dbus_string_get_length (&str) == i);
511  _dbus_assert (_dbus_string_get_length (&other) == a + 6 + 6);
513  "Foo Hello String Hello"));
514 
515  if (!_dbus_string_replace_len (&str, 6, 5,
516  &other, 4, 12))
517  _dbus_assert_not_reached ("could not replace with shorter string");
518 
519  _dbus_assert (_dbus_string_get_length (&str) == i);
520  _dbus_assert (_dbus_string_get_length (&other) == a + 5);
522  "Foo World Hello"));
523 
524  if (!_dbus_string_replace_len (&str, 0, 1,
525  &other, 0, 3))
526  _dbus_assert_not_reached ("could not replace at the beginning");
527 
528  _dbus_assert (_dbus_string_get_length (&str) == i);
529  _dbus_assert (_dbus_string_get_length (&other) == a + 3);
531  "H World Hello"));
532 
533  if (!_dbus_string_replace_len (&str, 6, 5,
534  &other,
535  _dbus_string_get_length (&other) - 5,
536  5))
537  _dbus_assert_not_reached ("could not replace same length");
538 
539  _dbus_assert (_dbus_string_get_length (&str) == i);
540  _dbus_assert (_dbus_string_get_length (&other) == a + 3);
542  "H World World"));
543 
544  _dbus_string_free (&str);
545  _dbus_string_free (&other);
546 
547  /* Check insert/set/get byte */
548 
549  if (!_dbus_string_init (&str))
550  _dbus_assert_not_reached ("failed to init string");
551 
552  if (!_dbus_string_append (&str, "Hello"))
553  _dbus_assert_not_reached ("failed to append Hello");
554 
555  _dbus_assert (_dbus_string_get_byte (&str, 0) == 'H');
556  _dbus_assert (_dbus_string_get_byte (&str, 1) == 'e');
557  _dbus_assert (_dbus_string_get_byte (&str, 2) == 'l');
558  _dbus_assert (_dbus_string_get_byte (&str, 3) == 'l');
559  _dbus_assert (_dbus_string_get_byte (&str, 4) == 'o');
560 
561  _dbus_string_set_byte (&str, 1, 'q');
562  _dbus_assert (_dbus_string_get_byte (&str, 1) == 'q');
563 
564  if (!_dbus_string_insert_bytes (&str, 0, 1, 255))
565  _dbus_assert_not_reached ("can't insert byte");
566 
567  if (!_dbus_string_insert_bytes (&str, 2, 4, 'Z'))
568  _dbus_assert_not_reached ("can't insert byte");
569 
570  if (!_dbus_string_insert_bytes (&str, _dbus_string_get_length (&str), 1, 'W'))
571  _dbus_assert_not_reached ("can't insert byte");
572 
573  _dbus_assert (_dbus_string_get_byte (&str, 0) == 255);
574  _dbus_assert (_dbus_string_get_byte (&str, 1) == 'H');
575  _dbus_assert (_dbus_string_get_byte (&str, 2) == 'Z');
576  _dbus_assert (_dbus_string_get_byte (&str, 3) == 'Z');
577  _dbus_assert (_dbus_string_get_byte (&str, 4) == 'Z');
578  _dbus_assert (_dbus_string_get_byte (&str, 5) == 'Z');
579  _dbus_assert (_dbus_string_get_byte (&str, 6) == 'q');
580  _dbus_assert (_dbus_string_get_byte (&str, 7) == 'l');
581  _dbus_assert (_dbus_string_get_byte (&str, 8) == 'l');
582  _dbus_assert (_dbus_string_get_byte (&str, 9) == 'o');
583  _dbus_assert (_dbus_string_get_byte (&str, 10) == 'W');
584 
585  _dbus_string_free (&str);
586 
587  /* Check append/parse int/double */
588 
589  if (!_dbus_string_init (&str))
590  _dbus_assert_not_reached ("failed to init string");
591 
592  if (!_dbus_string_append_int (&str, 27))
593  _dbus_assert_not_reached ("failed to append int");
594 
595  i = _dbus_string_get_length (&str);
596 
597  if (!_dbus_string_parse_int (&str, 0, &v, &end))
598  _dbus_assert_not_reached ("failed to parse int");
599 
600  _dbus_assert (v == 27);
601  _dbus_assert (end == i);
602 
603  _dbus_string_free (&str);
604 
605  /* Test find */
606  if (!_dbus_string_init (&str))
607  _dbus_assert_not_reached ("failed to init string");
608 
609  if (!_dbus_string_append (&str, "Hello"))
610  _dbus_assert_not_reached ("couldn't append to string");
611 
612  if (!_dbus_string_find (&str, 0, "He", &i))
613  _dbus_assert_not_reached ("didn't find 'He'");
614  _dbus_assert (i == 0);
615 
616  if (!_dbus_string_find (&str, 0, "Hello", &i))
617  _dbus_assert_not_reached ("didn't find 'Hello'");
618  _dbus_assert (i == 0);
619 
620  if (!_dbus_string_find (&str, 0, "ello", &i))
621  _dbus_assert_not_reached ("didn't find 'ello'");
622  _dbus_assert (i == 1);
623 
624  if (!_dbus_string_find (&str, 0, "lo", &i))
625  _dbus_assert_not_reached ("didn't find 'lo'");
626  _dbus_assert (i == 3);
627 
628  if (!_dbus_string_find (&str, 2, "lo", &i))
629  _dbus_assert_not_reached ("didn't find 'lo'");
630  _dbus_assert (i == 3);
631 
632  if (_dbus_string_find (&str, 4, "lo", &i))
633  _dbus_assert_not_reached ("did find 'lo'");
634 
635  if (!_dbus_string_find (&str, 0, "l", &i))
636  _dbus_assert_not_reached ("didn't find 'l'");
637  _dbus_assert (i == 2);
638 
639  if (!_dbus_string_find (&str, 0, "H", &i))
640  _dbus_assert_not_reached ("didn't find 'H'");
641  _dbus_assert (i == 0);
642 
643  if (!_dbus_string_find (&str, 0, "", &i))
644  _dbus_assert_not_reached ("didn't find ''");
645  _dbus_assert (i == 0);
646 
647  if (_dbus_string_find (&str, 0, "Hello!", NULL))
648  _dbus_assert_not_reached ("Did find 'Hello!'");
649 
650  if (_dbus_string_find (&str, 0, "Oh, Hello", NULL))
651  _dbus_assert_not_reached ("Did find 'Oh, Hello'");
652 
653  if (_dbus_string_find (&str, 0, "ill", NULL))
654  _dbus_assert_not_reached ("Did find 'ill'");
655 
656  if (_dbus_string_find (&str, 0, "q", NULL))
657  _dbus_assert_not_reached ("Did find 'q'");
658 
659  if (!_dbus_string_find_to (&str, 0, 2, "He", NULL))
660  _dbus_assert_not_reached ("Didn't find 'He'");
661 
662  if (_dbus_string_find_to (&str, 0, 2, "Hello", NULL))
663  _dbus_assert_not_reached ("Did find 'Hello'");
664 
665  if (!_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str), 'H', &i))
666  _dbus_assert_not_reached ("Did not find 'H'");
667  _dbus_assert (i == 0);
668 
669  if (!_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str), 'o', &i))
670  _dbus_assert_not_reached ("Did not find 'o'");
671  _dbus_assert (i == _dbus_string_get_length (&str) - 1);
672 
673  if (_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str) - 1, 'o', &i))
674  _dbus_assert_not_reached ("Did find 'o'");
675  _dbus_assert (i == -1);
676 
677  if (_dbus_string_find_byte_backward (&str, 1, 'e', &i))
678  _dbus_assert_not_reached ("Did find 'e'");
679  _dbus_assert (i == -1);
680 
681  if (!_dbus_string_find_byte_backward (&str, 2, 'e', &i))
682  _dbus_assert_not_reached ("Didn't find 'e'");
683  _dbus_assert (i == 1);
684 
685  _dbus_string_free (&str);
686 
687  /* Hex encoding */
688  _dbus_string_init_const (&str, "cafebabe, this is a bogus hex string");
689  if (!_dbus_string_init (&other))
690  _dbus_assert_not_reached ("could not init string");
691 
692  if (!_dbus_string_hex_decode (&str, 0, &end, &other, 0))
693  _dbus_assert_not_reached ("deccoded bogus hex string with no error");
694 
695  _dbus_assert (end == 8);
696 
697  _dbus_string_free (&other);
698 
699  test_roundtrips (test_hex_roundtrip);
700 
701  _dbus_string_free (&str);
702 
703  {
704  int found, found_len;
705 
706  _dbus_string_init_const (&str, "012\r\n567\n90");
707 
708  if (!_dbus_string_find_eol (&str, 0, &found, &found_len) || found != 3 || found_len != 2)
709  _dbus_assert_not_reached ("Did not find '\\r\\n'");
710  if (found != 3 || found_len != 2)
711  _dbus_assert_not_reached ("invalid return values");
712 
713  if (!_dbus_string_find_eol (&str, 5, &found, &found_len))
714  _dbus_assert_not_reached ("Did not find '\\n'");
715  if (found != 8 || found_len != 1)
716  _dbus_assert_not_reached ("invalid return values");
717 
718  if (_dbus_string_find_eol (&str, 9, &found, &found_len))
719  _dbus_assert_not_reached ("Found not expected '\\n'");
720  else if (found != 11 || found_len != 0)
721  _dbus_assert_not_reached ("invalid return values '\\n'");
722 
723  found = -1;
724  found_len = -1;
725  _dbus_string_init_const (&str, "");
726  if (_dbus_string_find_eol (&str, 0, &found, &found_len))
727  _dbus_assert_not_reached ("found an eol in an empty string");
728  _dbus_assert (found == 0);
729  _dbus_assert (found_len == 0);
730 
731  found = -1;
732  found_len = -1;
733  _dbus_string_init_const (&str, "foobar");
734  if (_dbus_string_find_eol (&str, 0, &found, &found_len))
735  _dbus_assert_not_reached ("found eol in string that lacks one");
736  _dbus_assert (found == 6);
737  _dbus_assert (found_len == 0);
738 
739  found = -1;
740  found_len = -1;
741  _dbus_string_init_const (&str, "foobar\n");
742  if (!_dbus_string_find_eol (&str, 0, &found, &found_len))
743  _dbus_assert_not_reached ("did not find eol in string that has one at end");
744  _dbus_assert (found == 6);
745  _dbus_assert (found_len == 1);
746  }
747 
748  {
749  DBusString line;
750 
751 #define FIRST_LINE "this is a line"
752 #define SECOND_LINE "this is a second line"
753  /* third line is empty */
754 #define THIRD_LINE ""
755 #define FOURTH_LINE "this is a fourth line"
756 
757  if (!_dbus_string_init (&str))
758  _dbus_assert_not_reached ("no memory");
759 
760  if (!_dbus_string_append (&str, FIRST_LINE "\n" SECOND_LINE "\r\n" THIRD_LINE "\n" FOURTH_LINE))
761  _dbus_assert_not_reached ("no memory");
762 
763  if (!_dbus_string_init (&line))
764  _dbus_assert_not_reached ("no memory");
765 
766  if (!_dbus_string_pop_line (&str, &line))
767  _dbus_assert_not_reached ("failed to pop first line");
768 
769  _dbus_assert (_dbus_string_equal_c_str (&line, FIRST_LINE));
770 
771  if (!_dbus_string_pop_line (&str, &line))
772  _dbus_assert_not_reached ("failed to pop second line");
773 
774  _dbus_assert (_dbus_string_equal_c_str (&line, SECOND_LINE));
775 
776  if (!_dbus_string_pop_line (&str, &line))
777  _dbus_assert_not_reached ("failed to pop third line");
778 
779  _dbus_assert (_dbus_string_equal_c_str (&line, THIRD_LINE));
780 
781  if (!_dbus_string_pop_line (&str, &line))
782  _dbus_assert_not_reached ("failed to pop fourth line");
783 
784  _dbus_assert (_dbus_string_equal_c_str (&line, FOURTH_LINE));
785 
786  _dbus_string_free (&str);
787  _dbus_string_free (&line);
788  }
789 
790  {
791  if (!_dbus_string_init (&str))
792  _dbus_assert_not_reached ("no memory");
793 
794  for (i = 0; i < 10000; i++)
795  if (!_dbus_string_append (&str, "abcdefghijklmnopqrstuvwxyz"))
796  _dbus_assert_not_reached ("no memory");
797 
798  if (!_dbus_string_set_length (&str, 10))
799  _dbus_assert_not_reached ("failed to set length");
800 
801  /* actually compact */
802  if (!_dbus_string_compact (&str, 2048))
803  _dbus_assert_not_reached ("failed to compact after set_length");
804 
805  /* peek inside to make sure it worked */
806  if (((DBusRealString *)&str)->allocated > 30)
807  _dbus_assert_not_reached ("compacting string didn't do anything");
808 
809  if (!_dbus_string_equal_c_str (&str, "abcdefghij"))
810  _dbus_assert_not_reached ("unexpected content after compact");
811 
812  /* compact nothing */
813  if (!_dbus_string_compact (&str, 2048))
814  _dbus_assert_not_reached ("failed to compact 2nd time");
815 
816  if (!_dbus_string_equal_c_str (&str, "abcdefghij"))
817  _dbus_assert_not_reached ("unexpected content after 2nd compact");
818 
819  /* and make sure it still works...*/
820  if (!_dbus_string_append (&str, "123456"))
821  _dbus_assert_not_reached ("failed to append after compact");
822 
823  if (!_dbus_string_equal_c_str (&str, "abcdefghij123456"))
824  _dbus_assert_not_reached ("unexpected content after append");
825 
826  /* after growing automatically, this should do nothing */
827  if (!_dbus_string_compact (&str, 20000))
828  _dbus_assert_not_reached ("failed to compact after grow");
829 
830  /* but this one will do something */
831  if (!_dbus_string_compact (&str, 0))
832  _dbus_assert_not_reached ("failed to compact after grow");
833 
834  if (!_dbus_string_equal_c_str (&str, "abcdefghij123456"))
835  _dbus_assert_not_reached ("unexpected content");
836 
837  if (!_dbus_string_append (&str, "!@#$%"))
838  _dbus_assert_not_reached ("failed to append after compact");
839 
840  if (!_dbus_string_equal_c_str (&str, "abcdefghij123456!@#$%"))
841  _dbus_assert_not_reached ("unexpected content");
842 
843  _dbus_string_free (&str);
844  }
845 
846  {
847  const char two_strings[] = "one\ttwo";
848 
849  if (!_dbus_string_init (&str))
850  _dbus_assert_not_reached ("no memory");
851 
852  if (!_dbus_string_init (&other))
853  _dbus_assert_not_reached ("no memory");
854 
855  if (!_dbus_string_append (&str, two_strings))
856  _dbus_assert_not_reached ("no memory");
857 
858  if (!_dbus_string_split_on_byte (&str, '\t', &other))
859  _dbus_assert_not_reached ("no memory or delimiter not found");
860 
861  if (strcmp (_dbus_string_get_data (&str), "one") != 0)
862  _dbus_assert_not_reached ("left side after split on tab is wrong");
863 
864  if (strcmp (_dbus_string_get_data (&other), "two") != 0)
865  _dbus_assert_not_reached ("right side after split on tab is wrong");
866 
867  _dbus_string_free (&str);
868  _dbus_string_free (&other);
869  }
870 
871  {
872  const char upper_string[] = "TOUPPERSTRING";
873  const char lower_string[] = "toupperstring";
874  const char lower2_string[] = "toupperSTRING";
875 
876  if (!_dbus_string_init (&str))
877  _dbus_assert_not_reached ("no memory");
878 
879  if (!_dbus_string_append (&str, upper_string))
880  _dbus_assert_not_reached ("no memory");
881 
882  _dbus_string_tolower_ascii (&str, 0, _dbus_string_get_length(&str));
883 
884  if (!_dbus_string_equal_c_str (&str, lower_string))
885  _dbus_assert_not_reached ("_dbus_string_tolower_ascii failed");
886 
887  _dbus_string_free (&str);
888 
889  if (!_dbus_string_init (&str))
890  _dbus_assert_not_reached ("no memory");
891 
892  if (!_dbus_string_append (&str, upper_string))
893  _dbus_assert_not_reached ("no memory");
894 
895  _dbus_string_tolower_ascii (&str, 0, 7);
896 
897  if (!_dbus_string_equal_c_str (&str, lower2_string))
898  _dbus_assert_not_reached ("_dbus_string_tolower_ascii failed in partial conversion");
899 
900  _dbus_string_free (&str);
901  }
902 
903  {
904  const char lower_string[] = "toupperstring";
905  const char upper_string[] = "TOUPPERSTRING";
906  const char upper2_string[] = "TOUPPERstring";
907 
908  if (!_dbus_string_init (&str))
909  _dbus_assert_not_reached ("no memory");
910 
911  if (!_dbus_string_append (&str, lower_string))
912  _dbus_assert_not_reached ("no memory");
913 
914  _dbus_string_toupper_ascii (&str, 0, _dbus_string_get_length(&str));
915 
916  if (!_dbus_string_equal_c_str (&str, upper_string))
917  _dbus_assert_not_reached ("_dbus_string_toupper_ascii failed");
918 
919  _dbus_string_free (&str);
920 
921  if (!_dbus_string_init (&str))
922  _dbus_assert_not_reached ("no memory");
923 
924  if (!_dbus_string_append (&str, lower_string))
925  _dbus_assert_not_reached ("no memory");
926 
927  _dbus_string_toupper_ascii (&str, 0, 7);
928 
929  if (!_dbus_string_equal_c_str (&str, upper2_string))
930  _dbus_assert_not_reached ("_dbus_string_toupper_ascii failed in partial conversion");
931 
932  _dbus_string_free (&str);
933  }
934 
935  return TRUE;
936 }
937 
938 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
dbus_bool_t _dbus_string_insert_bytes(DBusString *str, int i, int n_bytes, unsigned char byte)
Inserts a number of bytes of a given value at the given position.
Definition: dbus-string.c:584
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
Definition: dbus-string.c:935
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_parse_int(const DBusString *str, int start, long *value_return, int *end_return)
Parses an integer contained in a DBusString.
Definition: dbus-sysdeps.c:437
#define NULL
A null pointer, defined appropriately for C or C++.
Internals of DBusString.
dbus_bool_t _dbus_string_equal(const DBusString *a, const DBusString *b)
Tests two DBusString for equality.
Definition: dbus-string.c:2013
dbus_bool_t _dbus_string_find_eol(const DBusString *str, int start, int *found, int *found_len)
Finds end of line ("\r\n" or "\n") in the string, returning TRUE and filling in the byte index where ...
Definition: dbus-string.c:1627
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:702
dbus_bool_t _dbus_string_hex_encode(const DBusString *source, int start, DBusString *dest, int insert_at)
Encodes a string in hex, the way MD5 and SHA-1 are usually encoded.
Definition: dbus-string.c:2259
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_append_int(DBusString *str, long value)
Appends an integer to a DBusString.
Definition: dbus-sysdeps.c:356
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
void _dbus_string_tolower_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to lower case.
Definition: dbus-string.c:2485
#define DBUS_CONST_STRING_PREAMBLE(str)
Checks assertions about a string that may be const or locked.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
Definition: dbus-string.c:780
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that&#39;s copied to the d...
Definition: dbus-string.c:1283
dbus_bool_t _dbus_string_ends_with_c_str(const DBusString *a, const char *c_str)
Returns whether a string ends with the given suffix.
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
Definition: dbus-string.c:1604
dbus_bool_t _dbus_string_move(DBusString *source, int start, DBusString *dest, int insert_at)
Moves the end of one string into another string.
Definition: dbus-string.c:1259
dbus_bool_t _dbus_string_equal_c_str(const DBusString *a, const char *c_str)
Checks whether a string is equal to a C string.
Definition: dbus-string.c:2152
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory.
Definition: dbus-string.c:389
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
#define DBUS_GENERIC_STRING_PREAMBLE(real)
Checks a bunch of assertions about a string object.
dbus_bool_t _dbus_string_replace_len(const DBusString *source, int start, int len, DBusString *dest, int replace_at, int replace_len)
Replaces a segment of dest string with a segment of source string.
Definition: dbus-string.c:1404
dbus_bool_t _dbus_string_pop_line(DBusString *source, DBusString *dest)
Assigns a newline-terminated or \r\n-terminated line from the front of the string to the given dest s...
Definition: dbus-string.c:1909
int len
Length without nul.
dbus_bool_t _dbus_string_equal_substring(const DBusString *a, int a_start, int a_len, const DBusString *b, int b_start)
Tests two sub-parts of two DBusString for equality.
Definition: dbus-string.c:2104
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
Definition: dbus-string.c:1157
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
#define TRUE
Expands to "1".
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
dbus_bool_t _dbus_string_find_byte_backward(const DBusString *str, int start, unsigned char byte, int *found)
Find the given byte scanning backward from the given start.
dbus_bool_t _dbus_string_hex_decode(const DBusString *source, int start, int *end_return, DBusString *dest, int insert_at)
Decodes a string from hex encoding.
Definition: dbus-string.c:2309
dbus_bool_t _dbus_string_append_len(DBusString *str, const char *buffer, int len)
Appends block of bytes with the given length to a DBusString.
Definition: dbus-string.c:1137
dbus_bool_t _dbus_string_find_to(const DBusString *str, int start, int end, const char *substr, int *found)
Finds the given substring in the string, up to a certain position, returning TRUE and filling in the ...
Definition: dbus-string.c:1697
unsigned char * str
String data, plus nul termination.
#define FALSE
Expands to "0".
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
Definition: dbus-string.c:802
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
Definition: dbus-string.c:641
void _dbus_string_toupper_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to upper case.
Definition: dbus-string.c:2516
dbus_bool_t _dbus_string_split_on_byte(DBusString *source, unsigned char byte, DBusString *tail)
Looks for the first occurance of a byte, deletes that byte, and moves everything after the byte to th...
Definition: dbus-string.c:1467