The Tor Browser / file comparison

comparison: xpcom/tests/TestStrings.cpp

xpcom/tests/TestStrings.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:6a74a0772c69
1 /* vim:set ts=2 sw=2 et cindent: */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include "nsString.h"
9 #include "nsStringBuffer.h"
10 #include "nsReadableUtils.h"
11 #include "nsCRTGlue.h"
12
13 namespace TestStrings {
14
15 void test_assign_helper(const nsACString& in, nsACString &_retval)
16 {
17 _retval = in;
18 }
19
20 bool test_assign()
21 {
22 nsCString result;
23 test_assign_helper(NS_LITERAL_CSTRING("a") + NS_LITERAL_CSTRING("b"), result);
24 bool r = strcmp(result.get(), "ab") == 0;
25 if (!r)
26 printf("[result=%s]\n", result.get());
27 return r;
28 }
29
30 bool test_assign_c()
31 {
32 nsCString c; c.Assign('c');
33 bool r = strcmp(c.get(), "c") == 0;
34 if (!r)
35 printf("[result=%s]\n", c.get());
36 return r;
37 }
38
39 bool test1()
40 {
41 NS_NAMED_LITERAL_STRING(empty, "");
42 const nsAString& aStr = empty;
43
44 nsAutoString buf(aStr);
45
46 int32_t n = buf.FindChar(',');
47
48 n = buf.Length();
49
50 buf.Cut(0, n + 1);
51 n = buf.FindChar(',');
52
53 if (n != kNotFound)
54 printf("n=%d\n", n);
55
56 return n == kNotFound;
57 }
58
59 bool test2()
60 {
61 nsCString data("hello world");
62 const nsACString& aStr = data;
63
64 nsCString temp(aStr);
65 temp.Cut(0, 6);
66
67 bool r = strcmp(temp.get(), "world") == 0;
68 if (!r)
69 printf("[temp=%s]\n", temp.get());
70 return r;
71 }
72
73 bool test_find()
74 {
75 nsCString src("<!DOCTYPE blah blah blah>");
76
77 int32_t i = src.Find("DOCTYPE", true, 2, 1);
78 if (i == 2)
79 return true;
80
81 printf("i=%d\n", i);
82 return false;
83 }
84
85 bool test_rfind()
86 {
87 const char text[] = "<!DOCTYPE blah blah blah>";
88 const char term[] = "bLaH";
89 nsCString src(text);
90 int32_t i;
91
92 i = src.RFind(term, true, 3, -1);
93 if (i != kNotFound)
94 {
95 printf("unexpected result searching from offset=3, i=%d\n", i);
96 return false;
97 }
98
99 i = src.RFind(term, true, -1, -1);
100 if (i != 20)
101 {
102 printf("unexpected result searching from offset=-1, i=%d\n", i);
103 return false;
104 }
105
106 i = src.RFind(term, true, 13, -1);
107 if (i != 10)
108 {
109 printf("unexpected result searching from offset=13, i=%d\n", i);
110 return false;
111 }
112
113 i = src.RFind(term, true, 22, 3);
114 if (i != 20)
115 {
116 printf("unexpected result searching from offset=22, i=%d\n", i);
117 return false;
118 }
119
120 return true;
121 }
122
123 bool test_rfind_2()
124 {
125 const char text[] = "<!DOCTYPE blah blah blah>";
126 nsCString src(text);
127 int32_t i = src.RFind("TYPE", false, 5, -1);
128 if (i == 5)
129 return true;
130
131 printf("i=%d\n", i);
132 return false;
133 }
134
135 bool test_rfind_3()
136 {
137 const char text[] = "urn:mozilla:locale:en-US:necko";
138 nsAutoCString value(text);
139 int32_t i = value.RFind(":");
140 if (i == 24)
141 return true;
142
143 printf("i=%d\n", i);
144 return false;
145 }
146
147 bool test_rfind_4()
148 {
149 nsCString value("a.msf");
150 int32_t i = value.RFind(".msf");
151 if (i != 1)
152 {
153 printf("i=%d\n", i);
154 return false;
155 }
156
157 return true;
158 }
159
160 bool test_findinreadable()
161 {
162 const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";
163 nsAutoCString value(text);
164
165 nsACString::const_iterator begin, end;
166 value.BeginReading(begin);
167 value.EndReading(end);
168 nsACString::const_iterator delim_begin (begin),
169 delim_end (end);
170
171 // Search for last !/ at the end of the string
172 if (!FindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end))
173 return false;
174 char *r = ToNewCString(Substring(delim_begin, delim_end));
175 // Should match the first "!/" but not the last
176 if ((delim_end == end) || (strcmp(r, "!/")!=0))
177 {
178 printf("r = %s\n", r);
179 nsMemory::Free(r);
180 return false;
181 }
182 nsMemory::Free(r);
183
184 delim_begin = begin;
185 delim_end = end;
186
187 // Search for first jar:
188 if (!FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
189 return false;
190
191 r = ToNewCString(Substring(delim_begin, delim_end));
192 // Should not match the first jar:, but the second one
193 if ((delim_begin != begin) || (strcmp(r, "jar:")!=0))
194 {
195 printf("r = %s\n", r);
196 nsMemory::Free(r);
197 return false;
198 }
199 nsMemory::Free(r);
200
201 // Search for jar: in a Substring
202 delim_begin = begin; delim_begin++;
203 delim_end = end;
204 if (!FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
205 return false;
206
207 r = ToNewCString(Substring(delim_begin, delim_end));
208 // Should not match the first jar:, but the second one
209 if ((delim_begin == begin) || (strcmp(r, "jar:")!=0))
210 {
211 printf("r = %s\n", r);
212 nsMemory::Free(r);
213 return false;
214 }
215 nsMemory::Free(r);
216
217 // Should not find a match
218 if (FindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end))
219 return false;
220
221 // When no match is found, range should be empty
222 if (delim_begin != delim_end)
223 return false;
224
225 // Should not find a match (search not beyond Substring)
226 delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;
227 delim_end = end;
228 if (FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
229 return false;
230
231 // When no match is found, range should be empty
232 if (delim_begin != delim_end)
233 return false;
234
235 // Should not find a match (search not beyond Substring)
236 delim_begin = begin;
237 delim_end = end; for (int i=0;i<7;i++) delim_end--;
238 if (FindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end))
239 return false;
240
241 // When no match is found, range should be empty
242 if (delim_begin != delim_end)
243 return false;
244
245 return true;
246 }
247
248 bool test_rfindinreadable()
249 {
250 const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";
251 nsAutoCString value(text);
252
253 nsACString::const_iterator begin, end;
254 value.BeginReading(begin);
255 value.EndReading(end);
256 nsACString::const_iterator delim_begin (begin),
257 delim_end (end);
258
259 // Search for last !/ at the end of the string
260 if (!RFindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end))
261 return false;
262 char *r = ToNewCString(Substring(delim_begin, delim_end));
263 // Should match the last "!/"
264 if ((delim_end != end) || (strcmp(r, "!/")!=0))
265 {
266 printf("r = %s\n", r);
267 nsMemory::Free(r);
268 return false;
269 }
270 nsMemory::Free(r);
271
272 delim_begin = begin;
273 delim_end = end;
274
275 // Search for last jar: but not the first one...
276 if (!RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
277 return false;
278
279 r = ToNewCString(Substring(delim_begin, delim_end));
280 // Should not match the first jar:, but the second one
281 if ((delim_begin == begin) || (strcmp(r, "jar:")!=0))
282 {
283 printf("r = %s\n", r);
284 nsMemory::Free(r);
285 return false;
286 }
287 nsMemory::Free(r);
288
289 // Search for jar: in a Substring
290 delim_begin = begin;
291 delim_end = begin; for (int i=0;i<6;i++) delim_end++;
292 if (!RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end)) {
293 printf("Search for jar: in a Substring\n");
294 return false;
295 }
296
297 r = ToNewCString(Substring(delim_begin, delim_end));
298 // Should not match the first jar:, but the second one
299 if ((delim_begin != begin) || (strcmp(r, "jar:")!=0))
300 {
301 printf("r = %s\n", r);
302 nsMemory::Free(r);
303 return false;
304 }
305 nsMemory::Free(r);
306
307 // Should not find a match
308 delim_begin = begin;
309 delim_end = end;
310 if (RFindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end)) {
311 printf("Should not find a match\n");
312 return false;
313 }
314
315 // When no match is found, range should be empty
316 if (delim_begin != delim_end) {
317 printf("1: When no match is found, range should be empty\n");
318 return false;
319 }
320
321 // Should not find a match (search not before Substring)
322 delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;
323 delim_end = end;
324 if (RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end)) {
325 printf("Should not find a match (search not before Substring)\n");
326 return false;
327 }
328
329 // When no match is found, range should be empty
330 if (delim_begin != delim_end) {
331 printf("2: When no match is found, range should be empty\n");
332 return false;
333 }
334
335 // Should not find a match (search not beyond Substring)
336 delim_begin = begin;
337 delim_end = end; for (int i=0;i<7;i++) delim_end--;
338 if (RFindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end)) {
339 printf("Should not find a match (search not beyond Substring)\n");
340 return false;
341 }
342
343 // When no match is found, range should be empty
344 if (delim_begin != delim_end) {
345 printf("3: When no match is found, range should be empty\n");
346 return false;
347 }
348
349 return true;
350 }
351
352 bool test_distance()
353 {
354 const char text[] = "abc-xyz";
355 nsCString s(text);
356 nsCString::const_iterator begin, end;
357 s.BeginReading(begin);
358 s.EndReading(end);
359 size_t d = Distance(begin, end);
360 bool r = (d == sizeof(text)-1);
361 if (!r)
362 printf("d=%u\n", d);
363 return r;
364 }
365
366 bool test_length()
367 {
368 const char text[] = "abc-xyz";
369 nsCString s(text);
370 size_t d = s.Length();
371 bool r = (d == sizeof(text)-1);
372 if (!r)
373 printf("d=%u\n", d);
374 return r;
375 }
376
377 bool test_trim()
378 {
379 const char text[] = " a\t $ ";
380 const char set[] = " \t$";
381
382 nsCString s(text);
383 s.Trim(set);
384 bool r = strcmp(s.get(), "a") == 0;
385 if (!r)
386 printf("[s=%s]\n", s.get());
387 return r;
388 }
389
390 bool test_replace_substr()
391 {
392 const char text[] = "abc-ppp-qqq-ppp-xyz";
393 nsCString s(text);
394 s.ReplaceSubstring("ppp", "www");
395 bool r = strcmp(s.get(), "abc-www-qqq-www-xyz") == 0;
396 if (!r)
397 {
398 printf("[s=%s]\n", s.get());
399 return false;
400 }
401
402 s.Assign("foobar");
403 s.ReplaceSubstring("foo", "bar");
404 s.ReplaceSubstring("bar", "");
405 r = strcmp(s.get(), "") == 0;
406 if (!r)
407 {
408 printf("[s=%s]\n", s.get());
409 return false;
410 }
411
412 s.Assign("foofoofoo");
413 s.ReplaceSubstring("foo", "foo");
414 r = strcmp(s.get(), "foofoofoo") == 0;
415 if (!r)
416 {
417 printf("[s=%s]\n", s.get());
418 return false;
419 }
420
421 s.Assign("foofoofoo");
422 s.ReplaceSubstring("of", "fo");
423 r = strcmp(s.get(), "fofoofooo") == 0;
424 if (!r)
425 {
426 printf("[s=%s]\n", s.get());
427 return false;
428 }
429
430 return true;
431 }
432
433 bool test_replace_substr_2()
434 {
435 const char *oldName = nullptr;
436 const char *newName = "user";
437 nsString acctName; acctName.AssignLiteral("forums.foo.com");
438 nsAutoString newAcctName, oldVal, newVal;
439 oldVal.AssignWithConversion(oldName);
440 newVal.AssignWithConversion(newName);
441 newAcctName.Assign(acctName);
442
443 // here, oldVal is empty. we are testing that this function
444 // does not hang. see bug 235355.
445 newAcctName.ReplaceSubstring(oldVal, newVal);
446
447 // we expect that newAcctName will be unchanged.
448 if (!newAcctName.Equals(acctName))
449 return false;
450
451 return true;
452 }
453
454 bool test_strip_ws()
455 {
456 const char text[] = " a $ ";
457 nsCString s(text);
458 s.StripWhitespace();
459 bool r = strcmp(s.get(), "a$") == 0;
460 if (!r)
461 printf("[s=%s]\n", s.get());
462 return r;
463 }
464
465 bool test_equals_ic()
466 {
467 nsCString s;
468 bool r = s.LowerCaseEqualsLiteral("view-source");
469 if (r)
470 printf("[r=%d]\n", r);
471 return !r;
472 }
473
474 bool test_fixed_string()
475 {
476 char buf[256] = "hello world";
477
478 nsFixedCString s(buf, sizeof(buf));
479
480 if (s.Length() != strlen(buf))
481 return false;
482
483 if (strcmp(s.get(), buf) != 0)
484 return false;
485
486 s.Assign("foopy doopy doo");
487 if (s.get() != buf)
488 return false;
489
490 return true;
491 }
492
493 bool test_concat()
494 {
495 nsCString bar("bar");
496 const nsACString& barRef = bar;
497
498 const nsPromiseFlatCString& result =
499 PromiseFlatCString(NS_LITERAL_CSTRING("foo") +
500 NS_LITERAL_CSTRING(",") +
501 barRef);
502 if (strcmp(result.get(), "foo,bar") == 0)
503 return true;
504
505 printf("[result=%s]\n", result.get());
506 return false;
507 }
508
509 bool test_concat_2()
510 {
511 nsCString fieldTextStr("xyz");
512 nsCString text("text");
513 const nsACString& aText = text;
514
515 nsAutoCString result( fieldTextStr + aText );
516
517 if (strcmp(result.get(), "xyztext") == 0)
518 return true;
519
520 printf("[result=%s]\n", result.get());
521 return false;
522 }
523
524 bool test_concat_3()
525 {
526 nsCString result;
527 nsCString ab("ab"), c("c");
528
529 result = ab + result + c;
530 if (strcmp(result.get(), "abc") == 0)
531 return true;
532
533 printf("[result=%s]\n", result.get());
534 return false;
535 }
536
537 bool test_xpidl_string()
538 {
539 nsXPIDLCString a, b;
540 a = b;
541 if (a != b)
542 return false;
543
544 a.Adopt(0);
545 if (a != b)
546 return false;
547
548 a.Append("foopy");
549 a.Assign(b);
550 if (a != b)
551 return false;
552
553 a.Insert("", 0);
554 a.Assign(b);
555 if (a != b)
556 return false;
557
558 const char text[] = "hello world";
559 *getter_Copies(a) = NS_strdup(text);
560 if (strcmp(a, text) != 0)
561 return false;
562
563 b = a;
564 if (strcmp(a, b) != 0)
565 return false;
566
567 a.Adopt(0);
568 nsACString::const_iterator begin, end;
569 a.BeginReading(begin);
570 a.EndReading(end);
571 char *r = ToNewCString(Substring(begin, end));
572 if (strcmp(r, "") != 0)
573 return false;
574 nsMemory::Free(r);
575
576 a.Adopt(0);
577 if (a != (const char*) 0)
578 return false;
579
580 /*
581 int32_t index = a.FindCharInSet("xyz");
582 if (index != kNotFound)
583 return false;
584 */
585
586 return true;
587 }
588
589 bool test_empty_assign()
590 {
591 nsCString a;
592 a.AssignLiteral("");
593
594 a.AppendLiteral("");
595
596 nsCString b;
597 b.SetCapacity(0);
598 return true;
599 }
600
601 bool test_set_length()
602 {
603 const char kText[] = "Default Plugin";
604 nsCString buf;
605 buf.SetCapacity(sizeof(kText)-1);
606 buf.Assign(kText);
607 buf.SetLength(sizeof(kText)-1);
608 if (strcmp(buf.get(), kText) != 0)
609 return false;
610 return true;
611 }
612
613 bool test_substring()
614 {
615 nsCString super("hello world"), sub("hello");
616
617 // this tests that |super| starts with |sub|,
618
619 bool r = sub.Equals(StringHead(super, sub.Length()));
620 if (!r)
621 return false;
622
623 // and verifies that |sub| does not start with |super|.
624
625 r = super.Equals(StringHead(sub, super.Length()));
626 if (r)
627 return false;
628
629 return true;
630 }
631
632 #define test_append(str, int, suffix) \
633 str.Truncate(); \
634 str.AppendInt(suffix = int ## suffix); \
635 if (!str.EqualsLiteral(#int)) { \
636 fputs("Error appending " #int "\n", stderr); \
637 return false; \
638 }
639
640 #define test_appends(int, suffix) \
641 test_append(str, int, suffix) \
642 test_append(cstr, int, suffix)
643
644 #define test_appendbase(str, prefix, int, suffix, base) \
645 str.Truncate(); \
646 str.AppendInt(suffix = prefix ## int ## suffix, base); \
647 if (!str.EqualsLiteral(#int)) { \
648 fputs("Error appending " #prefix #int "\n", stderr); \
649 return false; \
650 }
651
652 #define test_appendbases(prefix, int, suffix, base) \
653 test_appendbase(str, prefix, int, suffix, base) \
654 test_appendbase(cstr, prefix, int, suffix, base)
655
656 bool test_appendint()
657 {
658 nsString str;
659 nsCString cstr;
660 int32_t L;
661 uint32_t UL;
662 int64_t LL;
663 uint64_t ULL;
664 test_appends(2147483647, L)
665 test_appends(-2147483648, L)
666 test_appends(4294967295, UL)
667 test_appends(9223372036854775807, LL)
668 test_appends(-9223372036854775808, LL)
669 test_appends(18446744073709551615, ULL)
670 test_appendbases(0, 17777777777, L, 8)
671 test_appendbases(0, 20000000000, L, 8)
672 test_appendbases(0, 37777777777, UL, 8)
673 test_appendbases(0, 777777777777777777777, LL, 8)
674 test_appendbases(0, 1000000000000000000000, LL, 8)
675 test_appendbases(0, 1777777777777777777777, ULL, 8)
676 test_appendbases(0x, 7fffffff, L, 16)
677 test_appendbases(0x, 80000000, L, 16)
678 test_appendbases(0x, ffffffff, UL, 16)
679 test_appendbases(0x, 7fffffffffffffff, LL, 16)
680 test_appendbases(0x, 8000000000000000, LL, 16)
681 test_appendbases(0x, ffffffffffffffff, ULL, 16)
682 return true;
683 }
684
685 bool test_appendint64()
686 {
687 nsCString str;
688
689 int64_t max = INT64_MAX;
690 static const char max_expected[] = "9223372036854775807";
691 int64_t min = INT64_MIN;
692 static const char min_expected[] = "-9223372036854775808";
693 static const char min_expected_oct[] = "1000000000000000000000";
694 int64_t maxint_plus1 = 1LL << 32;
695 static const char maxint_plus1_expected[] = "4294967296";
696 static const char maxint_plus1_expected_x[] = "100000000";
697
698 str.AppendInt(max);
699
700 if (!str.Equals(max_expected)) {
701 fprintf(stderr, "Error appending INT64_MAX: Got %s\n", str.get());
702 return false;
703 }
704
705 str.Truncate();
706 str.AppendInt(min);
707 if (!str.Equals(min_expected)) {
708 fprintf(stderr, "Error appending INT64_MIN: Got %s\n", str.get());
709 return false;
710 }
711 str.Truncate();
712 str.AppendInt(min, 8);
713 if (!str.Equals(min_expected_oct)) {
714 fprintf(stderr, "Error appending INT64_MIN (oct): Got %s\n", str.get());
715 return false;
716 }
717
718
719 str.Truncate();
720 str.AppendInt(maxint_plus1);
721 if (!str.Equals(maxint_plus1_expected)) {
722 fprintf(stderr, "Error appending UINT32_MAX + 1: Got %s\n", str.get());
723 return false;
724 }
725 str.Truncate();
726 str.AppendInt(maxint_plus1, 16);
727 if (!str.Equals(maxint_plus1_expected_x)) {
728 fprintf(stderr, "Error appending UINT32_MAX + 1 (hex): Got %s\n", str.get());
729 return false;
730 }
731
732
733 return true;
734 }
735
736 bool test_appendfloat()
737 {
738 nsCString str;
739 double bigdouble = 11223344556.66;
740 static const char double_expected[] = "11223344556.66";
741 static const char float_expected[] = "0.01";
742
743 // AppendFloat is used to append doubles, therefore the precision must be
744 // large enough (see bug 327719)
745 str.AppendFloat( bigdouble );
746 if (!str.Equals(double_expected)) {
747 fprintf(stderr, "Error appending a big double: Got %s\n", str.get());
748 return false;
749 }
750
751 str.Truncate();
752 // AppendFloat is used to append floats (bug 327719 #27)
753 str.AppendFloat( 0.1f * 0.1f );
754 if (!str.Equals(float_expected)) {
755 fprintf(stderr, "Error appending a float: Got %s\n", str.get());
756 return false;
757 }
758
759 return true;
760 }
761
762 bool test_findcharinset()
763 {
764 nsCString buf("hello, how are you?");
765
766 int32_t index = buf.FindCharInSet(",?", 5);
767 if (index != 5)
768 return false;
769
770 index = buf.FindCharInSet("helo", 0);
771 if (index != 0)
772 return false;
773
774 index = buf.FindCharInSet("z?", 6);
775 if (index != (int32_t) buf.Length()-1)
776 return false;
777
778 return true;
779 }
780
781 bool test_rfindcharinset()
782 {
783 nsCString buf("hello, how are you?");
784
785 int32_t index = buf.RFindCharInSet(",?", 5);
786 if (index != 5)
787 return false;
788
789 index = buf.RFindCharInSet("helo", 0);
790 if (index != 0)
791 return false;
792
793 index = buf.RFindCharInSet("z?", 6);
794 if (index != kNotFound)
795 return false;
796
797 index = buf.RFindCharInSet("l", 5);
798 if (index != 3)
799 return false;
800
801 buf.Assign("abcdefghijkabc");
802
803 index = buf.RFindCharInSet("ab");
804 if (index != 12)
805 return false;
806
807 index = buf.RFindCharInSet("ab", 11);
808 if (index != 11)
809 return false;
810
811 index = buf.RFindCharInSet("ab", 10);
812 if (index != 1)
813 return false;
814
815 index = buf.RFindCharInSet("ab", 0);
816 if (index != 0)
817 return false;
818
819 index = buf.RFindCharInSet("cd", 1);
820 if (index != kNotFound)
821 return false;
822
823 index = buf.RFindCharInSet("h");
824 if (index != 7)
825 return false;
826
827 return true;
828 }
829
830 bool test_stringbuffer()
831 {
832 const char kData[] = "hello world";
833
834 nsStringBuffer *buf;
835
836 buf = nsStringBuffer::Alloc(sizeof(kData));
837 if (!buf)
838 return false;
839 buf->Release();
840
841 buf = nsStringBuffer::Alloc(sizeof(kData));
842 if (!buf)
843 return false;
844 char *data = (char *) buf->Data();
845 memcpy(data, kData, sizeof(kData));
846
847 nsCString str;
848 buf->ToString(sizeof(kData)-1, str);
849
850 nsStringBuffer *buf2;
851 buf2 = nsStringBuffer::FromString(str);
852
853 bool rv = (buf == buf2);
854
855 buf->Release();
856 return rv;
857 }
858
859 bool test_voided()
860 {
861 const char kData[] = "hello world";
862
863 nsXPIDLCString str;
864 if (str)
865 return false;
866 if (!str.IsVoid())
867 return false;
868 if (!str.IsEmpty())
869 return false;
870
871 str.Assign(kData);
872 if (strcmp(str, kData) != 0)
873 return false;
874
875 str.SetIsVoid(true);
876 if (str)
877 return false;
878 if (!str.IsVoid())
879 return false;
880 if (!str.IsEmpty())
881 return false;
882
883 str.SetIsVoid(false);
884 if (strcmp(str, "") != 0)
885 return false;
886
887 return true;
888 }
889
890 bool test_voided_autostr()
891 {
892 const char kData[] = "hello world";
893
894 nsAutoCString str;
895 if (str.IsVoid())
896 return false;
897 if (!str.IsEmpty())
898 return false;
899
900 str.Assign(kData);
901 if (strcmp(str.get(), kData) != 0)
902 return false;
903
904 str.SetIsVoid(true);
905 if (!str.IsVoid())
906 return false;
907 if (!str.IsEmpty())
908 return false;
909
910 str.Assign(kData);
911 if (str.IsVoid())
912 return false;
913 if (str.IsEmpty())
914 return false;
915 if (strcmp(str.get(), kData) != 0)
916 return false;
917
918 return true;
919 }
920
921 bool test_voided_assignment()
922 {
923 nsCString a, b;
924 b.SetIsVoid(true);
925 a = b;
926 return a.IsVoid() && a.get() == b.get();
927 }
928
929 bool test_empty_assignment()
930 {
931 nsCString a, b;
932 a = b;
933 return a.get() == b.get();
934 }
935
936 struct ToIntegerTest
937 {
938 const char *str;
939 uint32_t radix;
940 int32_t result;
941 nsresult rv;
942 };
943
944 static const ToIntegerTest kToIntegerTests[] = {
945 { "123", 10, 123, NS_OK },
946 { "7b", 16, 123, NS_OK },
947 { "90194313659", 10, 0, NS_ERROR_ILLEGAL_VALUE },
948 { nullptr, 0, 0, 0 }
949 };
950
951 bool test_string_tointeger()
952 {
953 int32_t i;
954 nsresult rv;
955 for (const ToIntegerTest* t = kToIntegerTests; t->str; ++t) {
956 int32_t result = nsAutoCString(t->str).ToInteger(&rv, t->radix);
957 if (rv != t->rv || result != t->result)
958 return false;
959 result = nsAutoCString(t->str).ToInteger(&i, t->radix);
960 if ((nsresult)i != t->rv || result != t->result)
961 return false;
962 }
963 return true;
964 }
965
966 static bool test_parse_string_helper(const char* str, char separator, int len,
967 const char* s1, const char* s2)
968 {
969 nsCString data(str);
970 nsTArray<nsCString> results;
971 if (!ParseString(data, separator, results))
972 return false;
973 if (int(results.Length()) != len)
974 return false;
975 const char* strings[] = { s1, s2 };
976 for (int i = 0; i < len; ++i) {
977 if (!results[i].Equals(strings[i]))
978 return false;
979 }
980 return true;
981 }
982
983 static bool test_parse_string_helper0(const char* str, char separator)
984 {
985 return test_parse_string_helper(str, separator, 0, nullptr, nullptr);
986 }
987
988 static bool test_parse_string_helper1(const char* str, char separator, const char* s1)
989 {
990 return test_parse_string_helper(str, separator, 1, s1, nullptr);
991 }
992
993 static bool test_parse_string_helper2(const char* str, char separator, const char* s1, const char* s2)
994 {
995 return test_parse_string_helper(str, separator, 2, s1, s2);
996 }
997
998 static bool test_parse_string()
999 {
1000 return test_parse_string_helper1("foo, bar", '_', "foo, bar") &&
1001 test_parse_string_helper2("foo, bar", ',', "foo", " bar") &&
1002 test_parse_string_helper2("foo, bar ", ' ', "foo,", "bar") &&
1003 test_parse_string_helper2("foo,bar", 'o', "f", ",bar") &&
1004 test_parse_string_helper0("", '_') &&
1005 test_parse_string_helper0(" ", ' ') &&
1006 test_parse_string_helper1(" foo", ' ', "foo") &&
1007 test_parse_string_helper1(" foo", ' ', "foo");
1008 }
1009
1010 static bool test_strip_chars_helper(const char16_t* str, const char16_t* strip, const nsAString& result, uint32_t offset=0)
1011 {
1012 nsAutoString tmp(str);
1013 nsAString& data = tmp;
1014 data.StripChars(strip, offset);
1015 return data.Equals(result);
1016 }
1017
1018 static bool test_strip_chars()
1019 {
1020 return test_strip_chars_helper(MOZ_UTF16("foo \r \nbar"),
1021 MOZ_UTF16(" \n\r"),
1022 NS_LITERAL_STRING("foobar")) &&
1023 test_strip_chars_helper(MOZ_UTF16("\r\nfoo\r\n"),
1024 MOZ_UTF16(" \n\r"),
1025 NS_LITERAL_STRING("foo")) &&
1026 test_strip_chars_helper(MOZ_UTF16("foo"),
1027 MOZ_UTF16(" \n\r"),
1028 NS_LITERAL_STRING("foo")) &&
1029 test_strip_chars_helper(MOZ_UTF16("foo"),
1030 MOZ_UTF16("fo"),
1031 NS_LITERAL_STRING("")) &&
1032 test_strip_chars_helper(MOZ_UTF16("foo"),
1033 MOZ_UTF16("foo"),
1034 NS_LITERAL_STRING("")) &&
1035 test_strip_chars_helper(MOZ_UTF16(" foo"),
1036 MOZ_UTF16(" "),
1037 NS_LITERAL_STRING(" foo"), 1);
1038 }
1039
1040 static bool test_huge_capacity()
1041 {
1042 nsString a, b, c, d, e, f, g, h, i, j, k, l, m, n;
1043 nsCString n1;
1044 bool fail = false;
1045 #undef ok
1046 #define ok(x) { fail |= !(x); }
1047
1048 ok(a.SetCapacity(1));
1049 ok(!a.SetCapacity(nsString::size_type(-1)/2));
1050 ok(a.SetCapacity(0)); // free the allocated memory
1051
1052 ok(b.SetCapacity(1));
1053 ok(!b.SetCapacity(nsString::size_type(-1)/2 - 1));
1054 ok(b.SetCapacity(0));
1055
1056 ok(c.SetCapacity(1));
1057 ok(!c.SetCapacity(nsString::size_type(-1)/2));
1058 ok(c.SetCapacity(0));
1059
1060 ok(!d.SetCapacity(nsString::size_type(-1)/2 - 1));
1061 ok(!d.SetCapacity(nsString::size_type(-1)/2));
1062 ok(d.SetCapacity(0));
1063
1064 ok(!e.SetCapacity(nsString::size_type(-1)/4));
1065 ok(!e.SetCapacity(nsString::size_type(-1)/4 + 1));
1066 ok(e.SetCapacity(0));
1067
1068 ok(!f.SetCapacity(nsString::size_type(-1)/2));
1069 ok(f.SetCapacity(0));
1070
1071 ok(!g.SetCapacity(nsString::size_type(-1)/4 + 1000));
1072 ok(!g.SetCapacity(nsString::size_type(-1)/4 + 1001));
1073 ok(g.SetCapacity(0));
1074
1075 ok(!h.SetCapacity(nsString::size_type(-1)/4+1));
1076 ok(!h.SetCapacity(nsString::size_type(-1)/2));
1077 ok(h.SetCapacity(0));
1078
1079 ok(i.SetCapacity(1));
1080 ok(i.SetCapacity(nsString::size_type(-1)/4 - 1000));
1081 ok(!i.SetCapacity(nsString::size_type(-1)/4 + 1));
1082 ok(i.SetCapacity(0));
1083
1084 ok(j.SetCapacity(nsString::size_type(-1)/4 - 1000));
1085 ok(!j.SetCapacity(nsString::size_type(-1)/4 + 1));
1086 ok(j.SetCapacity(0));
1087
1088 ok(k.SetCapacity(nsString::size_type(-1)/8 - 1000));
1089 ok(k.SetCapacity(nsString::size_type(-1)/4 - 1001));
1090 ok(k.SetCapacity(nsString::size_type(-1)/4 - 998));
1091 ok(!k.SetCapacity(nsString::size_type(-1)/4 + 1));
1092 ok(k.SetCapacity(0));
1093
1094 ok(l.SetCapacity(nsString::size_type(-1)/8));
1095 ok(l.SetCapacity(nsString::size_type(-1)/8 + 1));
1096 ok(l.SetCapacity(nsString::size_type(-1)/8 + 2));
1097 ok(l.SetCapacity(0));
1098
1099 ok(m.SetCapacity(nsString::size_type(-1)/8 + 1000));
1100 ok(m.SetCapacity(nsString::size_type(-1)/8 + 1001));
1101 ok(m.SetCapacity(0));
1102
1103 ok(n.SetCapacity(nsString::size_type(-1)/8+1));
1104 ok(!n.SetCapacity(nsString::size_type(-1)/4));
1105 ok(n.SetCapacity(0));
1106
1107 ok(n.SetCapacity(0));
1108 ok(n.SetCapacity((nsString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 2 - 2));
1109 ok(n.SetCapacity(0));
1110 ok(!n.SetCapacity((nsString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 2 - 1));
1111 ok(n.SetCapacity(0));
1112 ok(n1.SetCapacity(0));
1113 ok(n1.SetCapacity((nsCString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 1 - 2));
1114 ok(n1.SetCapacity(0));
1115 ok(!n1.SetCapacity((nsCString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 1 - 1));
1116 ok(n1.SetCapacity(0));
1117
1118 // Ignore the result if the address space is less than 64-bit because
1119 // some of the allocations above will exhaust the address space.
1120 if (sizeof(void*) >= 8) {
1121 return !fail;
1122 }
1123 return true;
1124 }
1125
1126 static bool test_tofloat_helper(const nsString& aStr, float aExpected, bool aSuccess)
1127 {
1128 int32_t result;
1129 return aStr.ToFloat(&result) == aExpected &&
1130 aSuccess ? result == NS_OK : result != NS_OK;
1131 }
1132
1133 static bool test_tofloat()
1134 {
1135 return \
1136 test_tofloat_helper(NS_LITERAL_STRING("42"), 42.f, true) &&
1137 test_tofloat_helper(NS_LITERAL_STRING("42.0"), 42.f, true) &&
1138 test_tofloat_helper(NS_LITERAL_STRING("-42"), -42.f, true) &&
1139 test_tofloat_helper(NS_LITERAL_STRING("+42"), 42, true) &&
1140 test_tofloat_helper(NS_LITERAL_STRING("13.37"), 13.37f, true) &&
1141 test_tofloat_helper(NS_LITERAL_STRING("1.23456789"), 1.23456789f, true) &&
1142 test_tofloat_helper(NS_LITERAL_STRING("1.98765432123456"), 1.98765432123456f, true) &&
1143 test_tofloat_helper(NS_LITERAL_STRING("0"), 0.f, true) &&
1144 test_tofloat_helper(NS_LITERAL_STRING("1.e5"), 100000, true) &&
1145 test_tofloat_helper(NS_LITERAL_STRING(""), 0.f, false) &&
1146 test_tofloat_helper(NS_LITERAL_STRING("42foo"), 42.f, false) &&
1147 test_tofloat_helper(NS_LITERAL_STRING("foo"), 0.f, false) &&
1148 true;
1149 }
1150
1151 static bool test_todouble_helper(const nsString& aStr, double aExpected, bool aSuccess)
1152 {
1153 int32_t result;
1154 return aStr.ToDouble(&result) == aExpected &&
1155 aSuccess ? result == NS_OK : result != NS_OK;
1156 }
1157
1158 static bool test_todouble()
1159 {
1160 return \
1161 test_todouble_helper(NS_LITERAL_STRING("42"), 42, true) &&
1162 test_todouble_helper(NS_LITERAL_STRING("42.0"), 42, true) &&
1163 test_todouble_helper(NS_LITERAL_STRING("-42"), -42, true) &&
1164 test_todouble_helper(NS_LITERAL_STRING("+42"), 42, true) &&
1165 test_todouble_helper(NS_LITERAL_STRING("13.37"), 13.37, true) &&
1166 test_todouble_helper(NS_LITERAL_STRING("1.23456789"), 1.23456789, true) &&
1167 test_todouble_helper(NS_LITERAL_STRING("1.98765432123456"), 1.98765432123456, true) &&
1168 test_todouble_helper(NS_LITERAL_STRING("123456789.98765432123456"), 123456789.98765432123456, true) &&
1169 test_todouble_helper(NS_LITERAL_STRING("0"), 0, true) &&
1170 test_todouble_helper(NS_LITERAL_STRING("1.e5"), 100000, true) &&
1171 test_todouble_helper(NS_LITERAL_STRING(""), 0, false) &&
1172 test_todouble_helper(NS_LITERAL_STRING("42foo"), 42, false) &&
1173 test_todouble_helper(NS_LITERAL_STRING("foo"), 0, false) &&
1174 true;
1175 }
1176
1177 //----
1178
1179 typedef bool (*TestFunc)();
1180
1181 static const struct Test
1182 {
1183 const char* name;
1184 TestFunc func;
1185 }
1186 tests[] =
1187 {
1188 { "test_assign", test_assign },
1189 { "test_assign_c", test_assign_c },
1190 { "test1", test1 },
1191 { "test2", test2 },
1192 { "test_find", test_find },
1193 { "test_rfind", test_rfind },
1194 { "test_rfind_2", test_rfind_2 },
1195 { "test_rfind_3", test_rfind_3 },
1196 { "test_rfind_4", test_rfind_4 },
1197 { "test_findinreadable", test_findinreadable },
1198 { "test_rfindinreadable", test_rfindinreadable },
1199 { "test_distance", test_distance },
1200 { "test_length", test_length },
1201 { "test_trim", test_trim },
1202 { "test_replace_substr", test_replace_substr },
1203 { "test_replace_substr_2", test_replace_substr_2 },
1204 { "test_strip_ws", test_strip_ws },
1205 { "test_equals_ic", test_equals_ic },
1206 { "test_fixed_string", test_fixed_string },
1207 { "test_concat", test_concat },
1208 { "test_concat_2", test_concat_2 },
1209 { "test_concat_3", test_concat_3 },
1210 { "test_xpidl_string", test_xpidl_string },
1211 { "test_empty_assign", test_empty_assign },
1212 { "test_set_length", test_set_length },
1213 { "test_substring", test_substring },
1214 { "test_appendint", test_appendint },
1215 { "test_appendint64", test_appendint64 },
1216 { "test_appendfloat", test_appendfloat },
1217 { "test_findcharinset", test_findcharinset },
1218 { "test_rfindcharinset", test_rfindcharinset },
1219 { "test_stringbuffer", test_stringbuffer },
1220 { "test_voided", test_voided },
1221 { "test_voided_autostr", test_voided_autostr },
1222 { "test_voided_assignment", test_voided_assignment },
1223 { "test_empty_assignment", test_empty_assignment },
1224 { "test_string_tointeger", test_string_tointeger },
1225 { "test_parse_string", test_parse_string },
1226 { "test_strip_chars", test_strip_chars },
1227 { "test_huge_capacity", test_huge_capacity },
1228 { "test_tofloat", test_tofloat },
1229 { "test_todouble", test_todouble },
1230 { nullptr, nullptr }
1231 };
1232
1233 }
1234
1235 using namespace TestStrings;
1236
1237 int main(int argc, char **argv)
1238 {
1239 int count = 1;
1240 if (argc > 1)
1241 count = atoi(argv[1]);
1242
1243 NS_LogInit();
1244
1245 while (count--)
1246 {
1247 for (const Test* t = tests; t->name != nullptr; ++t)
1248 {
1249 printf("%25s : %s\n", t->name, t->func() ? "SUCCESS" : "FAILURE <--");
1250 }
1251 }
1252
1253 return 0;
1254 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial