feisty meow concerns codebase  2.140
test_string.cpp
Go to the documentation of this file.
1 /*****************************************************************************\
2 * *
3 * Name : test_string *
4 * Author : Chris Koeritz *
5 * *
6 *******************************************************************************
7 * Copyright (c) 1992-$now By Author. This program is free software; you can *
8 * redistribute it and/or modify it under the terms of the GNU General Public *
9 * License as published by the Free Software Foundation; either version 2 of *
10 * the License or (at your option) any later version. This is online at: *
11 * http://www.fsf.org/copyleft/gpl.html *
12 * Please send any updates to: fred@gruntose.com *
13 \*****************************************************************************/
14 
15 //#define DEBUG_STRING
16  // set this to enable debugging features of the string class.
17 
19 #include <basis/astring.h>
20 #include <basis/enhance_cpp.h>
21 #include <basis/functions.h>
22 #include <basis/guards.h>
24 #include <loggers/file_logger.h>
25 #include <mathematics/chaos.h>
29 #include <textual/byte_formatter.h>
30 #include <textual/string_convert.h>
32 #include <timely/earth_time.h>
33 #include <timely/time_stamp.h>
34 #include <unit_test/unit_base.h>
35 
36 //#ifdef _MSC_VER
37 // #include <comdef.h>
38 //#endif
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 
43 using namespace application;
44 using namespace basis;
45 using namespace loggers;
46 using namespace mathematics;
47 using namespace structures;
48 using namespace textual;
49 using namespace timely;
50 using namespace unit_test;
51 
52 //HOOPLE_STARTUP_CODE;
53 
54 //#define DEBUG_STRING_TEST
55  // uncomment for testing version.
56 
57 const float TEST_RUNTIME_DEFAULT = .02 * MINUTE_ms;
58  // the test, by default, will run for this long.
59 
61 
62 class test_string : public application_shell, public unit_base
63 {
64 public:
65  test_string() {}
66  ~test_string() {}
67 
68  DEFINE_CLASS_NAME("test_string");
69 
70  virtual int execute();
71 
72  void run_test_01();
73  void run_test_02();
74  void run_test_03();
75  void run_test_04();
76  void run_test_05();
77  void run_test_06();
78  void run_test_07();
79  void run_test_08();
80  void run_test_09();
81  void run_test_10();
82  void run_test_11();
83  void run_test_12();
84  void run_test_13();
85  void run_test_14();
86  void run_test_15();
87  void run_test_16();
88  void run_test_17();
89  void run_test_18();
90  void run_test_19();
91  void run_test_20();
92  void run_test_21();
93  void run_test_22();
94  void run_test_23();
95  void run_test_24();
96  void run_test_25();
97  void run_test_26();
98  void run_test_27();
99  void run_test_28();
100  void run_test_29();
101  void run_test_30();
102  void run_test_31();
103  void run_test_32();
104  void run_test_33();
105  void run_test_34();
106  void run_test_35();
107  void run_test_36();
108  void run_test_37();
109  void run_test_38();
110  void run_test_39();
111  void run_test_40();
112  void run_test_41();
113  void run_test_42();
114 };
115 
117 
119 
120 #define LOG(s) EMERGENCY_LOG(program_wide_logger::get(), s)
121 
122 #define WHERE __WHERE__.s()
123 
124 // test: reports an error if the condition evaluates to non-zero.
125 #define test(expr) { \
126  ASSERT_FALSE(expr, astring("operator test should work: ") + #expr); \
127 }
128 
129 static basis::astring staticity_test("yo!");
130  // used below to check whether static strings are looking right.
131 
133 
134 void test_string::run_test_01()
135 {
136  FUNCDEF("run_test_01");
137 
138 // const int TEST_EMPTY = 10000000;
139 // time_stamp started;
140 // for (int i = 0; i < TEST_EMPTY; i++) {
141 // astring glob = astring::empty_string();
142 // }
143 // int duration = int(time_stamp().value() - started.value());
144 // LOG(a_sprintf("duration of empty string test=%d ms", duration));
145 
146  // test simple string operations, like construction, length, equality.
147  astring fred1("hyeargh!");
148  astring fred2("matey.");
149  astring fred3;
150  fred3 = fred1;
151  fred3 += fred2;
152  astring fred4(fred2);
153 
154  ASSERT_EQUAL(fred1.length(), int(strlen(fred1.s())), "length should be correct (a).");
155  ASSERT_EQUAL(fred2.length(), int(strlen(fred2.s())), "length should be correct (b).");
156  ASSERT_EQUAL(fred3.length(), int(strlen(fred3.s())), "length should be correct (c).");
157  ASSERT_EQUAL(fred4.length(), int(strlen(fred4.s())), "length should be correct (d).");
158 
159 #ifdef DEBUG_STRING_TEST
160  LOG("[ " + fred1 + " & " + fred2 + "] -> " + fred3);
161 #endif
162 
163  ASSERT_EQUAL(fred1, astring("hyeargh!"), "failure in comparison (a).");
164  ASSERT_EQUAL(fred2, astring("matey."), "failure in comparison (b).");
165  ASSERT_EQUAL(fred3, astring("hyeargh!matey."), "failure in comparison (c).");
166  ASSERT_EQUAL(fred4, astring("matey."), "failure in comparison (d-1).");
167  ASSERT_EQUAL(fred4, fred2, "failure in comparison (d-2).");
168 
169  a_sprintf nullo;
170  ASSERT_EQUAL(nullo, astring(), "forward blank a_sprintf isn't blank.");
171  ASSERT_EQUAL(astring(), nullo, "backward blank a_sprintf isn't blank.");
172  ASSERT_EQUAL(nullo, astring::empty_string(), "forward blank a_sprintf isn't empty.");
173  ASSERT_EQUAL(astring::empty_string(), nullo, "backward blank a_sprintf isn't empty.");
174 }
175 
176 void test_string::run_test_02()
177 {
178  FUNCDEF("run_test_02");
179  // assorted tests involving strings as pointers.
180  astring *fred1 = new astring("flipper ate");
181  astring *fred2 = new astring(" my sandwich.");
182  astring *fred3 = new astring;
183  *fred3 = *fred1;
184  *fred3 += *fred2;
185 
186  // testing adding a null to a string.
187  *fred2 += (char *)NULL_POINTER;
188  *fred3 += (char *)NULL_POINTER;
189 
190 #ifdef DEBUG_STRING_TEST
191  LOG(astring("[ ") + *fred1 + " & " + *fred2 + "] -> " + *fred3);
192 #endif
193 
194  ASSERT_EQUAL(*fred1, astring("flipper ate"), "flipper A failure in comparison");
195  ASSERT_EQUAL(*fred2, astring(" my sandwich."), "sandwich A failure in comparison");
196  ASSERT_EQUAL(*fred3, astring("flipper ate my sandwich."), "full f-s A failure in comparison");
197  delete fred1;
198  delete fred2;
199  delete fred3;
200 }
201 
202 void test_string::run_test_03()
203 {
204  FUNCDEF("run_test_03");
205  // tests some things about zap.
206  astring fleermipe("hello my frobious.");
207  fleermipe.zap(0, fleermipe.length() - 1);
208  ASSERT_EQUAL(fleermipe.length(), 0, "length not 0 after deleting entire astring");
209 }
210 
211 void test_string::run_test_04()
212 {
213  FUNCDEF("run_test_04");
214  astring test_string("this test string will be chopped up.");
215 #ifdef DEBUG_STRING_TEST
216  LOG(astring("original is: ") + test_string);
217 #endif
218  astring fred(test_string.s());
219  fred.zap(0, fred.find('w'));
220 
221 #ifdef DEBUG_STRING_TEST
222  LOG(astring("now, the one chopped through 'w' is: ") + fred);
223 #endif
224 
225  ASSERT_EQUAL(fred, astring("ill be chopped up."), "first zap failed");
226 
227  astring blorg(test_string);
228  blorg.zap(blorg.find('p'), blorg.length() - 1);
229 #ifdef DEBUG_STRING_TEST
230  LOG(astring("now the one chopped from p to the end: ") + blorg);
231 #endif
232 
233  ASSERT_EQUAL(blorg, astring("this test string will be cho"), "second zap failed");
234 
235  astring fleen;
236  fleen += test_string;
237  fleen.zap(7, 14);
238 #ifdef DEBUG_STRING_TEST
239  LOG(astring("now the one with 7 through 14 missing: ") + fleen);
240 #endif
241 
242  ASSERT_EQUAL(fleen, astring("this teg will be chopped up."), "third zap failed");
243 
244 #ifdef DEBUG_STRING_TEST
245  LOG(astring("original astring is now: ") + test_string);
246 #endif
247  ASSERT_EQUAL(test_string, astring("this test string will be chopped up."),
248  "original astring was changed");
249 }
250 
251 void test_string::run_test_05()
252 {
253  FUNCDEF("run_test_05");
254 #ifdef DEBUG_STRING_TEST
255  LOG("about to test weird things:");
256 #endif
257  astring frieda("glorp");
258  astring jorb(frieda);
259  astring *kleeg = new astring(jorb.s());
260  astring plok = frieda;
261  test(frieda != jorb);
262  test(jorb != *kleeg);
263  test(*kleeg != plok);
264  test(plok != frieda);
265  astring glorp("glorp");
266  test(frieda != glorp);
267 
268  WHACK(kleeg);
269 
270 #ifdef DEBUG_STRING_TEST
271  LOG("strings matched up okay.");
272 #endif
273 
274  // test new features sprintf is relying upon.
275  astring bubba("gumpternations");
276  bubba += "_02193";
277 #ifdef DEBUG_STRING_TEST
278  LOG(astring("bubba = ") + bubba);
279 #endif
280  ASSERT_EQUAL(bubba, astring("gumpternations_02193"), "+= on char pointer failed.");
281 
282  astring bubelah("laksos");
283  bubelah += '3';
284  bubelah += '8';
285  bubelah += '2';
286 #ifdef DEBUG_STRING_TEST
287  LOG(astring("bubelah = ") + bubelah);
288 #endif
289  ASSERT_EQUAL(bubelah, astring("laksos382"), "+= on char failed.");
290 
291  astring simple_spr0(astring::SPRINTF, "%% yoga splorch %%");
292 #ifdef DEBUG_STRING_TEST
293  LOG(astring("simple sprintf 0 = ") + simple_spr0);
294 #endif
295  ASSERT_EQUAL(simple_spr0, astring("% yoga splorch %"), "simple sprintf 0 is wrong");
296  astring simple_spr1(astring::SPRINTF, "%d", 23);
297 #ifdef DEBUG_STRING_TEST
298  LOG(astring("simple sprintf 1 = ") + simple_spr1);
299 #endif
300  ASSERT_EQUAL(simple_spr1, astring("23"), "simple sprintf 1 is wrong");
301  astring simple_spr2(astring::SPRINTF, "%s", "yoyo");
302 #ifdef DEBUG_STRING_TEST
303  LOG(astring("simple sprintf 2 = ") + simple_spr2);
304 #endif
305  ASSERT_EQUAL(simple_spr2, astring("yoyo"), "simple sprintf 2 is wrong");
306 
307  astring sprintest(astring::SPRINTF, "%s has got me up the %s some %d "
308  "times, in %p with %d and %lu.", "marge", "ladder", 32, &kleeg,
309  812377487L, 213123123L);
310  astring sprintest2;
311  sprintest2.reset(astring::SPRINTF, "%s has got me up the %s some %d "
312  "times, in %p with %d and %lu.", "marge", "ladder", 32, &kleeg,
313  812377487L, 213123123L);
314  astring addr(astring::SPRINTF, "%p", &kleeg);
315 #ifdef DEBUG_STRING_TEST
316  LOG("here is your astring sir...");
317  LOG(sprintest);
318  LOG("and addr we will see is...");
319  LOG(addr);
320 #endif
321  if (sprintest != astring(astring::SPRINTF, "marge has got me up the "
322  "ladder some 32 times, in %s with 812377487 and 213123123.", addr.s()))
323  "constructed astring is wrong";
324  if (sprintest2 != astring(astring::SPRINTF, "marge has got me up the "
325  "ladder some 32 times, in %s with 812377487 and 213123123.", addr.s()))
326  "reset astring is wrong";
327 }
328 
329 void test_string::run_test_06()
330 {
331  FUNCDEF("run_test_06");
332  astring bungee;
333  bungee += "this astring";
334  bungee += " has been constructed gradua";
335  bungee += 'l';
336  bungee += 'l';
337  bungee += 'y';
338  astring blorpun(astring::SPRINTF, " out of severa%c", 'l');
339  bungee += blorpun;
340  bungee += " different bits,\nincluding";
341  astring freeple(astring::SPRINTF, "%s constructed %s blarg from %f ", " this", "silly", 3.14159265358);
342  bungee += freeple;
343  bungee += "radians awa";
344  bungee += 'y';
345  bungee += '.';
346  bungee += "\nhow does it look?\n";
347 #ifdef DEBUG_STRING_TEST
348  LOG(bungee);
349 #endif
350 
351 //MessageBox(0, bungee.s(), "yo, got this", MB_ICONINFORMATION | MB_OK);
352  ASSERT_EQUAL(bungee, astring("this astring has been constructed gradually out of several different bits,\nincluding this constructed silly blarg from 3.141593 radians away.\nhow does it look?\n"), "constructed astring is wrong");
353 }
354 
355 void test_string::run_test_07()
356 {
357  FUNCDEF("run_test_07");
358  astring a("axes");
359  astring b("bakesales");
360  astring x("xylophone");
361 
362  test(a >= x);
363  test(a == b);
364  test(a > b);
365  test(b >= x);
366  test(x <= a);
367  test(x != x);
368  test(a != a);
369 #ifdef DEBUG_STRING_TEST
370  LOG("comparisons worked");
371 #endif
372 }
373 
374 void test_string::run_test_08()
375 {
376  FUNCDEF("run_test_08");
377 #ifdef DEBUG_STRING_TEST
378  LOG("now testing + operator");
379 #endif
380  astring a("fred");
381  astring b(" is");
382  astring c(" his");
383  astring d(" name.");
384  astring e;
385  e = a + b + c + d;
386 #ifdef DEBUG_STRING_TEST
387  LOG(astring("result is: ") + e);
388 #endif
389  astring f;
390  f = d + c + b + a;
391 #ifdef DEBUG_STRING_TEST
392  LOG(astring("reverse is: ") + f);
393 #endif
394  astring g;
395  g = a + c + d + b;
396 #ifdef DEBUG_STRING_TEST
397  LOG(astring("tibetan style is: ") + g);
398 #endif
399  ASSERT_EQUAL(e, astring("fred is his name."), "astring looks wrong");
400  ASSERT_EQUAL(f, astring(" name. his isfred"), "astring looks wrong");
401  ASSERT_EQUAL(g, astring("fred his name. is"), "astring looks wrong");
402 }
403 
404 void test_string::run_test_09()
405 {
406  FUNCDEF("run_test_09");
407  astring bleer(astring::SPRINTF, "urghla burgla #%d\n", 23);
408  char holder[50];
409  for (int i = 0; i < bleer.length(); i++) {
410  bleer.stuff(holder, i);
411 #ifdef DEBUG_STRING_TEST
412  LOG(astring(astring::SPRINTF, "%d", i) + " has: " + holder);
413 #endif
414  astring my_copy(bleer);
415  my_copy.zap(i, bleer.length() - 1);
416  ASSERT_EQUAL(my_copy, astring(holder), "should see no inaccurate stuff() call");
417  }
418 }
419 
420 void test_string::run_test_10()
421 {
422  FUNCDEF("run_test_10");
423 #ifdef DEBUG_STRING_TEST
424  LOG("The tenth ones:");
425 #endif
426  astring george("this one will be mangled.");
427  ASSERT_EQUAL(george.length(), int(strlen(george.s())), "length is incorrect (q).");
428  astring tmp1(george.substring(1, 7)); // constructor.
429  astring tmp2 = george.substring(10, george.length() - 1); // constructor.
430 #ifdef DEBUG_STRING_TEST
431  LOG(tmp1 + "... " + tmp2);
432 #endif
433  ASSERT_INEQUAL(tmp1, tmp2, "bizarre equality occurred!");
434  ASSERT_FALSE( (tmp1 > tmp2) || (tmp2 < tmp1), "bizarre comparison error.");
435  ASSERT_EQUAL(george.length(), int(strlen(george.s())), "length is incorrect (z).");
436 #ifdef DEBUG_STRING_TEST
437  LOG(george.substring(1, 7));
438  LOG("... ");
439  LOG(george.substring(10, george.length() - 1));
440 #endif
441  ASSERT_EQUAL(george.length(), int(strlen(george.s())), "length is incorrect (a).");
442  george.insert(14, "terribly ");
443  ASSERT_EQUAL(george.length(), int(strlen(george.s())), "length is incorrect (b).");
444 #ifdef DEBUG_STRING_TEST
445  LOG(george);
446 #endif
447  astring chunky;
448  astring mssr_boef_la_tet("eeyoy eye eye capn");
449  mssr_boef_la_tet.substring(chunky, 2, 7);
450  ASSERT_EQUAL(chunky, astring("yoy ey"), "contents wrong after substring");
451 
452  astring fred(george);
453  ASSERT_TRUE(george.compare(fred, 0, 0, george.length() - 1, true), "did not work");
454  ASSERT_TRUE(george.compare(fred, 8, 8, george.length() - 1 - 8, true), "partial did not work");
455 
456  astring taco1("iLikeTacosNSuch");
457  astring taco2("iLikeTaCosNSuch");
458  ASSERT_TRUE(taco1.compare(taco2, 0, 0, taco1.length() - 1, false),
459  "tacos case-insensitive compare A did not work");
460  ASSERT_FALSE(taco1.compare(taco2, 0, 0, taco1.length() - 1, true),
461  "tacos case-sensitive compare B did not work");
462 
463  ASSERT_EQUAL(george.length(), int(strlen(george.s())), "length is incorrect (c).");
464  george.zap(14, 22);
465 #ifdef DEBUG_STRING_TEST
466  LOG(george);
467 #endif
468  astring fred_part;
469  fred_part = fred.substring(0, 13);
470  ASSERT_EQUAL(fred_part.length(), int(strlen(fred_part.s())), "length incorrect (d).");
471  ASSERT_TRUE(george.compare(fred_part, 0, 0, 13, true), "did not work");
472  fred_part = fred.substring(23, fred.length() - 1);
473  ASSERT_EQUAL(fred_part.length(), int(strlen(fred_part.s())), "length incorrect (e).");
474  ASSERT_TRUE(george.compare(fred_part, 14, 0, fred_part.length() - 1, true), "did not work");
475 #ifdef DEBUG_STRING_TEST
476  LOG("compares okay");
477 #endif
478 }
479 
480 void test_string::run_test_11()
481 {
482  FUNCDEF("run_test_11");
483  astring empty;
484  ASSERT_FALSE(empty.length(), "empty string judged not");
485  ASSERT_TRUE(!empty, "not on empty string doesn't work");
486  astring non_empty("grungee");
487  ASSERT_TRUE(non_empty.length(), "non-empty string judged empty");
488  ASSERT_FALSE(!non_empty, "not on non-empty string doesn't work");
489 }
490 
491 void test_string::run_test_12()
492 {
493  FUNCDEF("run_test_12");
494  astring elf0(astring::SPRINTF, "%%_%%_%%");
495  ASSERT_FALSE(strcmp(elf0.s(), "%_%_%"), "failed %% printing");
496 
497  char fred[6] = { 'h', 'y', 'a', 'r', 'g', '\0' };
498  astring fred_copy(astring::UNTERMINATED, fred, 5);
499  ASSERT_EQUAL(fred_copy.length(), 5, "length of copy is wrong");
500  ASSERT_EQUAL(fred_copy, astring("hyarg"), "length of copy is wrong");
501 
502  char hugh[6] = { 'o', 'y', 'o', 'b', 'o', 'y' };
503  astring hugh_copy(astring::UNTERMINATED, hugh, 3);
504  ASSERT_EQUAL(hugh_copy.length(), 3, "length of copy is wrong");
505  ASSERT_EQUAL(hugh_copy, astring("oyo"), "length of copy is wrong");
506 
507  astring another_copy;
508  another_copy.reset(astring::UNTERMINATED, fred, strlen(fred));
509  ASSERT_EQUAL(another_copy.length(), 5, "length of reset copy is wrong");
510  ASSERT_EQUAL(another_copy, astring("hyarg"), "length of reset copy is wrong");
511 }
512 
513 void test_string::run_test_13()
514 {
515  FUNCDEF("run_test_13");
516  // check for possible memory leaks in these combined ops.... 13th.
517  const astring churg("borjh sjh oiweoklj");
518  astring pud = churg;
519  astring flug = "kase iqk aksjir kljasdo";
520  const char *nerf = "ausd qwoeui sof zjh qwei";
521  astring snorp = nerf;
522  pud = "snugbo";
523  snorp = flug;
524  astring pundit("murph");
525  pundit = nerf;
526 }
527 
528 void test_string::run_test_14()
529 {
530  FUNCDEF("run_test_14");
531  // test the new dynamic sprintf'ing for long strings... 14th.
532  const int longish_size = 5000;
533  char temp[longish_size];
534  for (int i = 0; i < longish_size; i++)
535  temp[i] = char(rando.inclusive(1, 255));
536  temp[longish_size - 1] = '\0';
537  a_sprintf longish("this is a really darned long string of stuff: %s,\nbut doesn't it look interesting?", temp);
538  // still with us?
539  longish.zap(longish.length() / 3, 2 * longish.length() / 3);
540  longish += longish;
541  ASSERT_EQUAL(longish.length(), int(strlen(longish.s())), "length is incorrect.");
542 }
543 
544 void test_string::run_test_15()
545 {
546  FUNCDEF("run_test_15");
547  // test the new dynamic sprintf'ing for long strings... 15th.
548  int try_1 = 32767;
549  astring testy(astring::SPRINTF, "%d", try_1);
550  ASSERT_INEQUAL(testy.convert(95), 95, "default value returned, so it failed.");
551  ASSERT_EQUAL(testy.convert(95), try_1, "correct value was not returned.");
552 
553  long try_2 = 2938754L;
554  testy = astring(astring::SPRINTF, "%ld", try_2);
555  ASSERT_INEQUAL((double)testy.convert(98L), (double)98L, "default value returned, so it failed.");
556  ASSERT_EQUAL((double)testy.convert(98L), (double)try_2, "correct value was not returned.");
557 
558  testy = astring(astring::SPRINTF, "%ld", try_2);
559  ASSERT_INEQUAL((double)testy.convert(98L), (double)98L, "default value returned, so it failed.");
560  ASSERT_EQUAL((double)testy.convert(98L), (double)try_2, "correct value was not returned.");
561 
562  float try_3 = float(2938.754); // weird msvcpp error if don't cast.
563  testy = astring(astring::SPRINTF, "%f", try_3);
564  float found = testy.convert(float(98.6));
565  ASSERT_INEQUAL(found, 98.6, "default value returned, so it failed.");
566  ASSERT_EQUAL(found, try_3, "correct value was not returned.");
567 
568  {
569  double try_4 = 25598437.712385;
570  testy = astring(astring::SPRINTF, "%f", try_4);
571  double found2 = testy.convert(double(98.6));
572  ASSERT_INEQUAL(found2, 98.6, "default value returned, so it failed.");
573  ASSERT_EQUAL(found2, try_4, "correct value was not returned.");
574  }
575 
576  {
577  double try_4 = 25598437.712385e38;
578  testy = astring(astring::SPRINTF, "%f", try_4);
579  double found2 = testy.convert(double(98.6));
580  ASSERT_INEQUAL(found2, 98.6, "default value returned, so it failed.");
581  ASSERT_EQUAL(found2, try_4, "correct value was not returned.");
582  }
583 }
584 
585 void test_string::run_test_16()
586 {
587  FUNCDEF("run_test_16");
588  // the 16th test group tests boundary checking.
589  astring gorf("abc");
590  for (int i = -3; i < 25; i++) gorf[i] = 't';
591  ASSERT_EQUAL(gorf, astring("ttt"), "correct value was not returned (a).");
592  ASSERT_EQUAL(gorf.length(), 3, "length is incorrect (a).");
593  gorf.insert(3, astring("bru"));
594  ASSERT_EQUAL(gorf, astring("tttbru"), "correct value was not returned (b).");
595  ASSERT_EQUAL(gorf.length(), 6, "length is incorrect (b).");
596  gorf.insert(35, astring("snu"));
597  ASSERT_EQUAL(gorf, astring("tttbru"), "correct value was not returned (c).");
598  ASSERT_EQUAL(gorf.length(), 6, "length is incorrect (c).");
599  gorf.insert(-30, astring("eep"));
600  ASSERT_EQUAL(gorf, astring("tttbru"), "correct value was not returned (d).");
601  ASSERT_EQUAL(gorf.length(), 6, "length is incorrect (d).");
602 }
603 
604 void test_string::run_test_17()
605 {
606  FUNCDEF("run_test_17");
607  // 17th test checks construction of temporaries.
608 /* this test set causes the obnoxious 16 bit codeguard error from hell, as
609  does use of temporary objects in ostream << operators. argh! */
610  astring("jubjo");
611  astring("obo");
612  astring("flrrpominort").substring(3, 6);
613 }
614 
615 void test_string::run_test_18()
616 {
617 #ifdef DEBUG_STRING_TEST
618  FUNCDEF("run_test_18");
619 #endif
620  // 18th test group checks windows related functions.
621 #ifdef AFXDLL
622  AfxSetResourceHandle(GET_INSTANCE_HANDLE());
623  // required for mfc to see the proper instance handle.
624 
625  // this tests the "constructor from resource".
626  astring libname = rc_string(IDS_BASIS_NAME);
627  ASSERT_EQUAL(libname, astring("Basis Library"),
628  astring("library name is a mismatch: comes out as \"") + libname + "\".");
629  #define IDS_SOME_BAD_UNKNOWN_STRING_HANDLE 30802
630  astring bogus_name = rc_string(IDS_SOME_BAD_UNKNOWN_STRING_HANDLE);
631  ASSERT_FALSE(bogus_name.length(), "bogus rc string had length");
632 
633  // tests conversions from CString to astring and back.
634  astring george("yo yo yo");
635  CString hal = convert(george);
636  astring borgia = convert(hal);
637 
638 #ifdef DEBUG_STRING_TEST
639  LOG(astring("cstringy conversions: ") + george);
640  LOG((const char *)hal);
641  LOG(borgia);
642 #endif
643 
644  ASSERT_EQUAL(borgia, george, "got the wrong value");
645 #endif
646 }
647 
648 void test_string::run_test_19()
649 {
650  FUNCDEF("run_test_19");
651  // 19th test group is devoted to anthony wenzel's % printing bug.
652  astring problematic_example(astring::SPRINTF, "this should have %d% more "
653  "stuffing than before!", 20);
654 //MessageBox(0, astring("got a string of \"%s!\"", problematic_example.s()).s(), "yo!", MB_OK);
655  ASSERT_EQUAL(problematic_example, astring("this should have 20% more stuffing than before!"), "failure to print correct phrase");
656 }
657 
658 void test_string::run_test_20()
659 {
660 #ifdef DEBUG_STRING_TEST
661  FUNCDEF("run_test_20");
662 #endif
663  // 20th test group is devoted to another wenzelbug.
664 
665  // Hey, I just found out (in an ugly way) that the following doesn't work:
666  char myText[] = "OK";
667  astring myString(astring::SPRINTF, "%04s", myText);
668 #ifdef DEBUG_STRING_TEST
669  LOG(astring("first try gets: ") + myString);
670 #endif
671 
672  char myText8[] = "OK";
673  char my_text_4[90];
674  sprintf(my_text_4, "%4s", myText8);
675 #ifdef DEBUG_STRING_TEST
676  LOG(astring("second try gets: ") + astring(my_text_4));
677 #endif
678 
679  // Looks like you don't handle the "%04s" arguments properly. I can make
680  // it work as follows:
681  char myText2[] = "OK";
682  char myText3[50];
683  sprintf(myText3, "%4s", myText2);
684  astring myString2(myText3);
685 #ifdef DEBUG_STRING_TEST
686  LOG(astring("third try gets: ") + myString2);
687 #endif
688 }
689 
690 void test_string::run_test_21()
691 {
692  FUNCDEF("run_test_21");
693  // 21st test group checks out the strip spaces and replace functions.
694  astring spacey(" dufunk ");
695  astring temp = spacey;
696  temp.strip_spaces(astring::FROM_FRONT);
697  ASSERT_EQUAL(temp, astring("dufunk "), "created wrong string");
698  temp = spacey;
699  temp.strip_spaces(astring::FROM_END);
700  ASSERT_EQUAL(temp, astring(" dufunk"), "created wrong string");
701  temp = spacey;
702  temp.strip_spaces(astring::FROM_BOTH_SIDES);
703  ASSERT_EQUAL(temp, astring("dufunk"), "created wrong string");
704 
705  astring placemat("mary had a red hooded cobra she kept around her neck "
706  "and it hissed at the people as they walked by her tent.");
707  ASSERT_TRUE(placemat.replace("had", "bought"), "replace failed");
708  ASSERT_TRUE(!placemat.replace("hoded", "bought"), "replace didn't fail but should have");
709  ASSERT_TRUE(placemat.replace("she", "funkateria"), "replace failed");
710  ASSERT_TRUE(placemat.replace("hooded", "hood"), "replace failed");
711  ASSERT_TRUE(placemat.replace("cobra", "in the"), "replace failed");
712 
713  int indy = placemat.find("kept");
714  ASSERT_FALSE(negative(indy), "couldn't find string");
715  placemat[indy - 1] = '.';
716  placemat.zap(indy, placemat.end());
717  ASSERT_EQUAL(placemat, astring("mary bought a red hood in the funkateria."), "got wrong result string");
718 }
719 
720 void test_string::run_test_22()
721 {
722  FUNCDEF("run_test_22");
723  // 22nd test: morgan's find bug.
724  astring B("buzz*buzz*");
725  {
726  int x = B.find('*'); // correctly finds the first *.
727  ASSERT_EQUAL(x, 4, "got wrong index for first");
728  x++;
729  x = B.find('*', x); // correctly finds the second *.
730  ASSERT_EQUAL(x, 9, "got wrong index for second");
731  x++; // now x == B.length().
732  x = B.find('*', x);
733  // error was: finds the second * again (and again and again and
734  // again...). At this point it should return OUT_OF_RANGE.
735  ASSERT_FALSE(x > 0, "got wrong outcome for third");
736  }
737  {
738  int x = B.find("z*"); // correctly finds the first z*.
739  ASSERT_EQUAL(x, 3, "got wrong index for fourth");
740  x++;
741  x = B.find("z*", x); // correctly finds the second *.
742  ASSERT_EQUAL(x, 8, "got wrong index for fifth");
743  x++; // now x == B.length().
744  x = B.find("z*", x);
745  // error was: finds the second * again (and again and again and
746  // again...). At this point it should return OUT_OF_RANGE.
747  ASSERT_FALSE(x > 0, "got wrong outcome for sixth");
748  }
749 }
750 
751 void test_string::run_test_23()
752 {
753  FUNCDEF("run_test_23");
754  // 23rd test: test the new strip function.
755  astring strip_string("!@#$%^&*()");
756 
757  astring no_stripper("this shouldn't change");
758  no_stripper.strip(strip_string, astring::FROM_BOTH_SIDES);
759  ASSERT_EQUAL(no_stripper, astring("this shouldn't change"), "first test failed comparison");
760 
761  astring strippee_orig("&$(*(@&@*()()!()@*(@(*fudge#((@(*@**#)(@#)(#");
762  astring strippee(strippee_orig);
763  strippee.strip(strip_string, astring::FROM_BOTH_SIDES);
764  ASSERT_EQUAL(strippee, astring("fudge"), "second test failed comparison");
765 
766  strippee = strippee_orig;
767  strippee.strip(strip_string, astring::FROM_FRONT);
768  ASSERT_EQUAL(strippee, astring("fudge#((@(*@**#)(@#)(#"), "third test failed comparison");
769 
770  strippee = strippee_orig;
771  strippee.strip(strip_string, astring::FROM_END);
772  ASSERT_EQUAL(strippee, astring("&$(*(@&@*()()!()@*(@(*fudge"), "fourth test failed comparison");
773 }
774 
775 void test_string::run_test_24()
776 {
777  FUNCDEF("run_test_24");
778 #ifndef __GNU_WINDOWS__
779 #ifdef __WIN32__
780  // 24th test group tests _bstr_t conversions.
781  _bstr_t beast("abcdefgh");
782 #ifdef DEBUG_STRING_TEST
783  LOG(astring("the beast is ") + beast.operator char *() +
784  astring(astring::SPRINTF, " with length %d", beast.length()));
785 #endif
786  astring convert = beast;
787 #ifdef DEBUG_STRING_TEST
788  LOG(astring("the convert is ") + convert
789  + astring(astring::SPRINTF, " with length %d", convert.length()));
790 #endif
791  ASSERT_EQUAL(convert, astring("abcdefgh"), "first test failed comparison");
792 
793  astring jethro("i want a hog sandwich");
794  _bstr_t pork = string_convert::to_bstr_t(jethro);
795  ASSERT_FALSE(strcmp(pork.operator char *(), jethro.s()), "second test failed comparison");
796 #endif
797 #endif
798 }
799 
800 void test_string::run_test_25()
801 {
802  FUNCDEF("run_test_25");
803  // 25th test group tests simple comparisons.
804  astring fred = "asdoiuaoisud";
805  ASSERT_INEQUAL(fred, astring(), "first test failed comparison");
806  astring bub = fred;
807  ASSERT_EQUAL(fred, bub, "second test failed comparison");
808  fred = "";
809  ASSERT_EQUAL(fred, astring(), "third test failed comparison");
810  ASSERT_FALSE(fred.length(), "fourth test failed comparison");
811 }
812 
813 void test_string::run_test_26()
814 {
815  FUNCDEF("run_test_26");
816  // 26th test group does simple time_stamp::notarize operations. these are more for
817  // ensuring boundschecker gets to see some of this.
818  astring t2 = time_stamp::notarize(false);
819  astring t4 = time_stamp::notarize(true);
820 }
821 
822 void test_string::run_test_27()
823 {
824  FUNCDEF("run_test_27");
825  // 27th test group plays around with idate in an attempt to get
826  // boundschecker to complain.
829  timely::time_locus dt1 = now();
830  astring sd1 = d1.text_form();
831  astring st1 = t1.text_form();
832  astring sdt1 = dt1.text_form_long();
833 }
834 
835 void test_string::run_test_28()
836 {
837  FUNCDEF("run_test_28");
838  // 28th test group does sprintfs on shorts and such.
839  basis::un_int in1 = 27;
840  basis::un_short in2 = 39;
841  char in3 = 'Q';
842  astring testy(astring::SPRINTF, "%u:%hu:%c", in1, in2, in3);
843  ASSERT_EQUAL(testy, astring("27:39:Q"), "fourth test failed comparison");
844 }
845 
846 void test_string::run_test_29()
847 {
848  FUNCDEF("run_test_29");
849  // 29th test group tries out the packing support.
850  astring a("would an onion smell so sweet?");
851  byte_array p1;
852  a.pack(p1);
853  astring b;
854  ASSERT_TRUE(b.unpack(p1), "first unpack failed");
855  ASSERT_EQUAL(b, a, "first comparison failed");
856  a = "128 salamanders cannot be wrong.";
857  a.pack(p1);
858  ASSERT_TRUE(b.unpack(p1), "second unpack failed");
859  ASSERT_EQUAL(b, a, "second comparison failed");
860 }
861 
862 void standard_sprintf_test(const char *parm_string)
863 {
864  FUNCDEF("standard_sprintf_test");
865  astring print_into(' ', 20000);
866  print_into[0] = '\0';
867 //check these!!!:
868  int i1 = int(rando.inclusive(0, 23945));
869  long l1 = long(rando.inclusive(-2394, 2998238));
870  un_int u1 = basis::un_int(rando.inclusive(0, 124395));
871  un_short s1 = basis::un_short(rando.inclusive(0, 65535));
872  sprintf(print_into.s(), "%d %ld %u %hu %s", i1, l1, u1, s1, parm_string);
873  sprintf(print_into.s(), "%c %d %c %s %s %lu", char(rando.inclusive('a', 'z')),
874  int(rando.inclusive(0, 23945)), char(rando.inclusive('A', 'Z')),
875  parm_string, parm_string, basis::un_long(rando.inclusive(0, 2998238)));
876 }
877 
878 void test_string::run_test_30()
879 {
880  // 30th test group checks astring sprintf.
881  FUNCDEF("run_test_30");
882  astring parm_string = string_manipulation::make_random_name(40, 140);
883  astring print_into(' ', 20000);
884  print_into[0] = '\0';
885  int i1 = int(rando.inclusive(0, 23945));
886  long l1 = long(rando.inclusive(-2394, 2998238));
887  un_int u1 = basis::un_int(rando.inclusive(0, 124395));
888  un_short s1 = basis::un_short(rando.inclusive(0, 65535));
889  char test_same[20010];
890  sprintf(test_same, "%d %ld %u %hu %s", i1, l1, u1, s1, parm_string.s());
891  print_into.sprintf("%d %ld %u %hu %s", i1, l1, u1, s1, parm_string.s());
892  ASSERT_EQUAL(astring(test_same), print_into, "sprintf should get same results as standard");
893 //do test for this one too.
894  print_into.sprintf("%c %d %c %s %s %lu", char(rando.inclusive('a', 'z')),
895  int(rando.inclusive(0, 23945)), char(rando.inclusive('A', 'Z')),
896  parm_string.observe(), parm_string.s(), basis::un_long(rando.inclusive(0, 2998238)));
897 }
898 
899 void test_string::run_test_31()
900 {
901  FUNCDEF("run_test_31");
902  // testing of character repeat constructor.
903  astring dashes('-', 20);
904  astring non_plusses('+', 0);
905  astring plusses('+', 1);
906  ASSERT_EQUAL(dashes.length(), 20, astring("dashes has wrong length!"));
907  ASSERT_EQUAL(dashes, astring("--------------------"), astring("dashes has wrong contents! '") + dashes + "' vs. '" + astring("--------------------'"));
908  ASSERT_FALSE(non_plusses.length(), astring("non_plusses has wrong length!"));
909  ASSERT_EQUAL(plusses.length(), 1, astring("plusses has wrong length!"));
910  ASSERT_EQUAL(plusses, astring("+"), astring("plusses has wrong contents!"));
911  ASSERT_EQUAL(plusses, astring('+', 1), astring("plusses second compare failed!"));
912 }
913 
914 void test_string::run_test_32()
915 {
916  FUNCDEF("run_test_32");
917  // tests creating a huge string and ripping it apart.
918 
919  const int CHUNK_SIZE = 2 * MEGABYTE;
920  // the block factor for our string. we expect not to go above this during
921  // the testing.
922  const int MIN_ADDITION = 10000; const int MAX_ADDITION = 80000;
923  // these are the largest chunk we add to a string at a time.
924  const int BUILD_AND_BURN_ITERATIONS = 1;
925  // number of times to test building up and tearing down.
926 
927  // the string we build up and tear down.
928  astring slab;
929 
930 //hmmm: maybe have a mixed phase where tearing and adding
931 // happens frequently and interspersed.
932 
933  for (int iters = 0; iters < BUILD_AND_BURN_ITERATIONS; iters++) {
934 
935  int size = 0; // independent count of expected size.
936  // we don't want to bother allocating the big chunk more than once, so
937  // we'll add to the string until it's within range of going over.
938  while (slab.length() < CHUNK_SIZE - MAX_ADDITION - 20) {
939 //make this into add_a_chunk
940  astring addition = string_manipulation::make_random_name(MIN_ADDITION,
941  MAX_ADDITION);
942  slab += addition;
943  size += addition.length();
944  ASSERT_EQUAL(size, slab.length(), astring("size is incorrect after add!"));
945  }
946 
947  // now we eat it up.
948  while (slab.length()) {
949 //make this into zap_a_chunk
950  int zap_start = rando.inclusive(0, slab.end());
951  int zap_end = rando.inclusive(0, slab.end());
952  flip_increasing(zap_start, zap_end);
953  int range_length = zap_end - zap_start + 1;
954  ASSERT_FALSE(negative(range_length), astring("flip_increasing failed!"));
955  slab.zap(zap_start, zap_end);
956  size -= range_length;
957  ASSERT_EQUAL(size, slab.length(), astring("size is incorrect after zap!"));
958  }
959  }
960 }
961 
962 void test_string::run_test_33()
963 {
964  FUNCDEF("run_test_33");
965  // 33rd test group exercises the replace functions.
966  {
967  astring to_modify("\\\\feeby\\path\\yo");
968  ASSERT_TRUE(to_modify.replace("\\", "/"), "failed to replace the string");
969  ASSERT_EQUAL(to_modify, astring("/\\feeby\\path\\yo"), "produced wrong resultant string");
970  while (to_modify.replace("\\", "/")) {}
971  ASSERT_EQUAL(to_modify, astring("//feeby/path/yo"), "produced wrong final string");
972  }
973  {
974  astring to_modify("\\superduper\\dynamo\\looper");
975  ASSERT_TRUE(to_modify.replace("\\", "/"), "failed to replace the string");
976  ASSERT_EQUAL(to_modify, astring("/superduper\\dynamo\\looper"), "produced wrong resultant string");
977  while (to_modify.replace("\\", "/")) {}
978  ASSERT_EQUAL(to_modify, astring("/superduper/dynamo/looper"), "produced wrong final string");
979  }
980  {
981  astring id = "/SRV=1/SRC=1";
982  astring id1 = id;
983  while (id1.replace("/", " ")) {}
984 // LOG(astring("replacing / with ' ' in first test (was ") + id +
985 // ") gives " + id1);
986  ASSERT_EQUAL(id1, astring(" SRV=1 SRC=1"), "produced wrong final string");
987 
988  astring id2 = id;
989  while (id2.replace("=", ":")) {}
990 // LOG(astring("replacing = with : in second test (was ") + id +
991 // ") gives " + id2);
992  ASSERT_EQUAL(id2, astring("/SRV:1/SRC:1"), "produced wrong final string");
993  }
994 }
995 
996 void test_string::run_test_34()
997 {
998  FUNCDEF("run_test_34");
999 
1000 //not in use right now.
1001 
1002 }
1003 
1004 void test_string::run_test_35()
1005 {
1006  FUNCDEF("run_test_35");
1007  // test the shrink method.
1008  astring termo('R', 2812);
1009  ASSERT_EQUAL(termo.length(), 2812, "length should be as requested");
1010  termo[1008] = '\0';
1011  termo.shrink();
1012  ASSERT_EQUAL(termo.get_implementation().internal_real_length(), 1010, a_sprintf("failure in shrunken size: " "wanted 1010 and got %d.", termo.get_implementation().internal_real_length()));
1013  astring termo2('R', 1008);
1014  ASSERT_EQUAL(termo, termo2, "wrong value produced");
1015 }
1016 
1017 void test_string::run_test_36()
1018 {
1019  FUNCDEF("run_test_36");
1020  // test the text form on a string array (which is mildly related to strings;
1021  // this could be moved to a common templates test someday).
1022  string_array torpid;
1023  torpid += "york";
1024  torpid += "burger";
1025  torpid += "petunia";
1026  torpid += "dumptruck";
1027  ASSERT_EQUAL(torpid.text_form(), astring("\"york\",\"burger\",\"petunia\",\"dumptruck\""), "wrong value computed");
1028  string_array sacral;
1029  sacral += "gumboat";
1030  ASSERT_EQUAL(sacral.text_form(), astring("\"gumboat\""), "wrong value computed");
1031 
1032  string_array paknid;
1033  paknid += "gorboochy";
1034  paknid += "rangolent";
1035  byte_array packed;
1036  structures::pack_array(packed, paknid);
1037 
1038  string_array upnort;
1039  ASSERT_TRUE(structures::unpack_array(packed, upnort), "failed to unpack");
1040  ASSERT_FALSE(packed.length(), "array still has bytes!");
1041 
1042  string_array stongent;
1043  stongent += "pemulack";
1044  stongent += "bluzzent";
1045  stongent += "crupto";
1046  stongent += "floonack";
1047  stongent += "atoona";
1048  packed.reset();
1049  structures::pack_array(packed, stongent);
1050 
1051  string_array belzorp;
1052  ASSERT_TRUE(structures::unpack_array(packed, belzorp), "failed to unpack");
1053  ASSERT_FALSE(packed.length(), "array still has bytes!");
1054 }
1055 
1056 void test_string::run_test_37()
1057 {
1058  FUNCDEF("run_test_37");
1059  // 37th test group used to try out the old packing support, but now is
1060  // just the same as test 29. it would be good to make this different.
1061  astring a("would an onion smell so sweet?");
1062  byte_array p1;
1063  a.pack(p1);
1064  astring b;
1065  ASSERT_TRUE(b.unpack(p1), "first unpack failed");
1066  ASSERT_EQUAL(b, a, "first comparison failed");
1067  a = "128 salamanders cannot be wrong.";
1068  a.pack(p1);
1069  ASSERT_TRUE(b.unpack(p1), "second unpack failed");
1070  ASSERT_EQUAL(b, a, "second comparison failed");
1071 }
1072 
1073 void test_string::run_test_38()
1074 {
1075  FUNCDEF("run_test_38");
1076  double to_print = 2.345;
1077  a_sprintf non_deadly("%.1f", to_print);
1079 
1080  to_print = 1.797E+254;
1081  // this value breaks things.
1082 
1083  char bucket[2000];
1084  bucket[0] = '\0';
1085  sprintf(bucket, "%.1f", to_print);
1087 
1088  a_sprintf deadly("%.1f", to_print);
1090 }
1091 
1092 void test_string::run_test_39()
1093 {
1094  FUNCDEF("run_test_39");
1095  const char *find_set = "!?.;";
1096  astring test_1 = "how do i get to balthazar square? it stinks!";
1097  ASSERT_EQUAL(test_1.find_any(find_set), 32, "first find returned wrong result");
1098  ASSERT_EQUAL(test_1.find_any(find_set, 33), 44, "second find returned wrong result");
1099  ASSERT_EQUAL(test_1.find_any(find_set, 40, true), 32, "third find returned wrong result");
1100 }
1101 
1102 void test_string::run_test_40()
1103 {
1104  FUNCDEF("run_test_40");
1105  int test_num = 1;
1106  #define test_name() a_sprintf("test %d: ", test_num)
1107  {
1108  astring target = "xabab";
1109  astring from = "ab";
1110  astring to = "dc";
1111  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1112  ASSERT_EQUAL(target, astring("xdcdc"), test_name() + "didn't replace properly");
1113  test_num++;
1114  }
1115  {
1116  astring target = "xabab";
1117  astring from = "ab";
1118  astring to = "ab";
1119  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1120  ASSERT_EQUAL(target, astring("xabab"), test_name() + "didn't replace properly");
1121  test_num++;
1122  }
1123  {
1124  astring target = "xabab";
1125  astring from = "ab";
1126  astring to = "a";
1127  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1128  ASSERT_EQUAL(target, astring("xaa"), test_name() + "didn't replace properly");
1129  test_num++;
1130  }
1131  {
1132  astring target = "ababx";
1133  astring from = "ab";
1134  astring to = "a";
1135  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1136  ASSERT_EQUAL(target, astring("aax"), test_name() + "didn't replace properly");
1137  test_num++;
1138  }
1139  {
1140  astring target = "suzzle rumpetzzes gnargle rezztor";
1141  astring from = "zz";
1142  astring to = "zzz";
1143  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1144  ASSERT_EQUAL(target, astring("suzzzle rumpetzzzes gnargle rezzztor"), test_name() + "didn't replace properly");
1145  test_num++;
1146  }
1147  {
1148  astring target = "qqqq";
1149  astring from = "q";
1150  astring to = "qqq";
1151  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1152  ASSERT_EQUAL(target, astring("qqqqqqqqqqqq"), test_name() + "didn't replace properly");
1153  test_num++;
1154  }
1155  {
1156  astring target = "glorg snorp pendle funk";
1157  astring from = " ";
1158  astring to = "";
1159  ASSERT_TRUE(target.replace_all(from, to), test_name() + "didn't find from string");
1160  ASSERT_EQUAL(target, astring("glorgsnorppendlefunk"), test_name() + "didn't replace properly");
1161  test_num++;
1162  }
1163 }
1164 
1165 void test_string::run_test_41()
1166 {
1167  FUNCDEF("run_test_41");
1168  int test_num = 0;
1169  #define test_name() a_sprintf("test %d: ", test_num)
1170  {
1171  test_num++;
1172  astring target = "xabab";
1173  const char *finding1 = "ab";
1174  ASSERT_EQUAL(target.find_non_match(finding1, 0, false), 0, test_name() + "didn't find right location A");
1175  const char *finding2 = "xb";
1176  ASSERT_EQUAL(target.find_non_match(finding2, target.length() - 1, true), 3, test_name() + "didn't find right location B");
1177  const char *finding3 = "c";
1178  ASSERT_EQUAL(target.find_non_match(finding3, 0, false), 0, test_name() + "wrong answer for test C");
1179  ASSERT_EQUAL(target.find_non_match(finding3, target.length() - 1, true), target.length() - 1,
1180  test_name() + "wrong answer for test D");
1181  }
1182  {
1183  test_num++;
1184  astring target = "abcadefghoota";
1185  const char *finding1 = "bcdfghot";
1186  ASSERT_EQUAL(target.find_non_match(finding1, 0, false), 0, test_name() + "didn't find right location A");
1187  ASSERT_EQUAL(target.find_non_match(finding1, 1, false), 3, test_name() + "didn't find right location B");
1188  ASSERT_EQUAL(target.find_non_match(finding1, target.length() - 1, true), target.length() - 1, test_name() + "didn't find right location C");
1189  ASSERT_EQUAL(target.find_non_match(finding1, target.length() - 2, true), 5, test_name() + "didn't find right location D");
1190  ASSERT_EQUAL(target.find_non_match(finding1, 3, false), 3, test_name() + "didn't find right location E");
1191  ASSERT_EQUAL(target.find_non_match(finding1, 4, false), 5, test_name() + "didn't find right location F");
1192 
1193  }
1194 
1195 }
1196 
1197 // exercise the middle, right and left methods.
1198 void test_string::run_test_42()
1199 {
1200  FUNCDEF("run_test_42");
1201 
1202  astring hobnob("all the best robots are bending robots");
1203 
1204  ASSERT_EQUAL(hobnob.middle(5, 7), astring("he best"), "failed to find middle of string");
1205  ASSERT_EQUAL(hobnob.right(10), astring("ing robots"), "failed to find right side of string");
1206  ASSERT_EQUAL(hobnob.left(6), astring("all th"), "failed to find right side of string");
1207 }
1208 
1210 
1211 int test_string::execute()
1212 {
1213  FUNCDEF("execute");
1214 
1215 // ASSERT_EQUAL(0, 1, "fake assertion to test jenkins log parsing");
1216  ASSERT_EQUAL(1, 1, "non-fake assertion to test jenkins log parsing");
1217 
1218  ASSERT_EQUAL(staticity_test, astring("yo!"), "wrong contents");
1219 
1220  time_stamp end_time(TEST_RUNTIME_DEFAULT);
1221  // when we're done testing.
1222 
1223  int i = 0; // iteration counter.
1224  while (time_stamp() < end_time) {
1225  // we run the test until our time runs out.
1226  i++; // next iteration.
1227 #ifdef DEBUG_STRING_TEST
1228  LOG(astring(astring::SPRINTF, "index %d", i));
1229 #endif
1230 
1231  // beginning of test sets.
1232  run_test_01();
1233  run_test_02();
1234  run_test_03();
1235  run_test_04();
1236  run_test_05();
1237  run_test_06();
1238  run_test_07();
1239  run_test_08();
1240  run_test_09();
1241  run_test_10();
1242  run_test_11();
1243  run_test_12();
1244  run_test_13();
1245  run_test_14();
1246  run_test_15();
1247  run_test_16();
1248  run_test_17();
1249  run_test_18();
1250  run_test_19();
1251  run_test_20();
1252  run_test_21();
1253  run_test_22();
1254  run_test_23();
1255  run_test_24();
1256  run_test_25();
1257  run_test_26();
1258  run_test_27();
1259  run_test_28();
1260  run_test_29();
1261 //too slow run_test_30();
1262  run_test_31();
1263  run_test_32();
1264  run_test_33();
1265 //retired run_test_34();
1266  run_test_35();
1267  run_test_36();
1268  run_test_37();
1269  run_test_38();
1270  run_test_39();
1271  run_test_40();
1272  run_test_41();
1273  run_test_42();
1274  }
1275 
1276  return final_report();
1277 }
1278 
1279 HOOPLE_MAIN(test_string, )
1280 
1281 
The application_shell is a base object for console programs.
a_sprintf is a specialization of astring that provides printf style support.
Definition: astring.h:440
void reset(int number=0, const contents *initial_contents=NULL_POINTER)
Resizes this array and sets the contents from an array of contents.
Definition: array.h:349
int length() const
Returns the current reported length of the allocated C array.
Definition: array.h:115
Provides a dynamically resizable ASCII character string.
Definition: astring.h:35
const char * s() const
synonym for observe. the 's' stands for "string", if that helps.
Definition: astring.h:113
bool replace(const astring &tag, const astring &replacement)
replaces the first occurrence of "tag" text with the "replacement".
Definition: astring.cpp:905
virtual void zap(int start, int end)
Deletes the characters between "start" and "end" inclusively.
Definition: astring.cpp:521
bool substring(astring &target, int start, int end) const
a version that stores the substring in an existing "target" string.
Definition: astring.cpp:865
void strip_spaces(how_to_strip way=FROM_BOTH_SIDES)
removes excess space characters from string's beginning, end or both.
Definition: astring.h:325
void reset()
clears out the contents string.
Definition: astring.h:202
int find_non_match(const char *to_find, int position=0, bool reverse=false) const
searches for any character that is not in "to_find" and returns index.
Definition: astring.cpp:583
int end() const
returns the index of the last (non-null) character in the string.
Definition: astring.h:86
int find_any(const char *to_find, int position=0, bool reverse=false) const
searches for any of the characters in "to_find".
Definition: astring.cpp:577
bool replace_all(char to_replace, char new_char)
changes all occurrences of "to_replace" with "new_char".
Definition: astring.cpp:929
int length() const
Returns the current length of the string.
Definition: astring.cpp:132
bool unpack(byte_array &source)
retrieves a string (packed with pack()) from "source" into this string.
Definition: astring.cpp:964
virtual const char * observe() const
observes the underlying pointer to the zero-terminated string.
Definition: astring.cpp:140
A very common template for a dynamic array of bytes.
Definition: byte_array.h:36
a platform-independent way to acquire random numbers in a specific range.
Definition: chaos.h:51
int inclusive(int low, int high) const
< Returns a pseudo-random number r, such that "low" <= r <= "high".
Definition: chaos.h:88
An array of strings with some additional helpful methods.
Definition: string_array.h:32
basis::astring text_form() const
A synonym for the text_format() method.
Definition: string_array.h:71
A specific point in time as represented by a 24 hour clock.
Definition: earth_time.h:85
basis::astring text_form(int how=MERIDIAN) const
Prints the clock_time according to "how".
Definition: earth_time.cpp:105
An object that represents a particular day in a year.
Definition: earth_time.h:139
basis::astring text_form(int how=SHORT_MONTH) const
Prints the day according to "how".
Definition: earth_time.cpp:197
An object that represents a particular point in time.
Definition: earth_time.h:188
basis::astring text_form_long(int t=clock_time::MERIDIAN, int d=day_in_year::SHORT_MONTH, int y=LONG_YEAR) const
Definition: earth_time.cpp:262
Represents a point in time relative to the operating system startup time.
Definition: time_stamp.h:38
#define NULL_POINTER
The value representing a pointer to nothing.
Definition: definitions.h:32
#define DEFINE_CLASS_NAME(objname)
Defines the name of a class by providing a couple standard methods.
Definition: enhance_cpp.h:45
#define FUNCDEF(func_in)
FUNCDEF sets the name of a function (and plugs it into the callstack).
Definition: enhance_cpp.h:57
Provides macros that implement the 'main' program of an application.
#define HOOPLE_MAIN(obj_name, obj_args)
options that should work for most unix and linux apps.
Definition: hoople_main.h:61
Implements an application lock to ensure only one is running at once.
The guards collection helps in testing preconditions and reporting errors.
Definition: array.h:30
void WHACK(contents *&ptr)
deletion with clearing of the pointer.
Definition: functions.h:121
const int MEGABYTE
Number of bytes in a megabyte.
Definition: definitions.h:135
unsigned long un_long
Abbreviated name for unsigned long integers.
Definition: definitions.h:66
unsigned int un_int
Abbreviated name for unsigned integers.
Definition: definitions.h:62
void flip_increasing(type &a, type &b)
Makes sure that two values are in increasing order (a < b).
Definition: functions.h:95
unsigned short un_short
Abbreviated name for unsigned short integers.
Definition: definitions.h:64
bool negative(const type &a)
negative returns true if "a" is less than zero.
Definition: functions.h:43
const int MINUTE_ms
Number of milliseconds in a minute.
Definition: definitions.h:121
A logger that sends to the console screen using the standard output device.
An extension to floating point primitives providing approximate equality.
Definition: averager.h:21
A dynamic container class that holds any kind of object via pointers.
Definition: amorph.h:55
bool unpack_array(basis::byte_array &packed_form, basis::array< contents > &to_unpack)
provides a way to unpack any array that stores packable objects.
void pack_array(basis::byte_array &packed_form, const basis::array< contents > &to_pack)
provides a way to pack any array that stores packable objects.
#include <time.h>
Definition: earth_time.cpp:37
time_locus now()
returns our current locus in the time continuum.
Definition: earth_time.cpp:352
clock_time time_now()
what time is it?
Definition: earth_time.cpp:386
time_locus convert(time_number seconds, time_number useconds, const tm &cal_values)
Definition: earth_time.cpp:326
day_in_year date_now()
what day on the calendar is it?
Definition: earth_time.cpp:394
Useful support functions for unit testing, especially within hoople.
Definition: unit_base.cpp:35
gerkin borgia
Definition: test_array.cpp:809
const float TEST_RUNTIME_DEFAULT
Definition: test_string.cpp:57
#define LOG(s)
#define test(expr)
#define test_name()
void standard_sprintf_test(const char *parm_string)
chaos rando
#define ASSERT_EQUAL(a, b, test_name)
Definition: unit_base.h:38
#define ASSERT_TRUE(a, test_name)
Definition: unit_base.h:46
#define ASSERT_FALSE(a, test_name)
Definition: unit_base.h:50
#define ASSERT_INEQUAL(a, b, test_name)
Definition: unit_base.h:42
#define GET_INSTANCE_HANDLE()
a handy macro that frees one from knowing the name of the handle.