|
1
5 package com.tctest.stringbuffer;
6
7 import org.apache.commons.lang.ClassUtils;
8
9 import com.tc.object.config.ConfigVisitor;
10 import com.tc.object.config.DSOClientConfigHelper;
11 import com.tc.simulator.app.ApplicationConfig;
12 import com.tc.simulator.listener.ListenerProvider;
13 import com.tc.util.Assert;
14 import com.tctest.GenericTestApp;
15
16 import java.security.SecureRandom  ;
17 import java.util.ArrayList ;
18 import java.util.Arrays ;
19 import java.util.Iterator ;
20 import java.util.List ;
21 import java.util.Random ;
22
23 public class StringBufferTestApp extends GenericTestApp {
24
25 public StringBufferTestApp(String appId, ApplicationConfig cfg, ListenerProvider listenerProvider) {
26 super(appId, cfg, listenerProvider, StringBuddy.class);
27 }
28
29 void testOp001(StringBuddy buffer, boolean validate) {
30 synchronized (buffer) {
31 if (validate) {
32 Assert.assertEquals("true", buffer.toString());
33 } else {
34 buffer.append(true);
35 }
36 }
37 }
38
39 void testOp002(StringBuddy buffer, boolean validate) {
40 synchronized (buffer) {
41 if (validate) {
42 Assert.assertEquals("x", buffer.toString());
43 } else {
44 buffer.append('x');
45 }
46 }
47 }
48
49 void testOp003(StringBuddy buffer, boolean validate) {
50 synchronized (buffer) {
51 if (validate) {
52 Assert.assertEquals("tim", buffer.toString());
53 } else {
54 buffer.append(new char[] { 't', 'i', 'm' });
55 }
56 }
57 }
58
59 void testOp004(StringBuddy buffer, boolean validate) {
60 synchronized (buffer) {
61 if (validate) {
62 Assert.assertEquals("666", buffer.toString());
63 } else {
64 buffer.append(new char[] { 'a', '6', '6', '6' }, 1, 3);
65 }
66 }
67 }
68
69 void testOp005(StringBuddy buffer, boolean validate) {
70 synchronized (buffer) {
71 if (validate) {
72 Assert.assertEquals(String.valueOf(Math.PI), buffer.toString());
73 } else {
74 buffer.append(Math.PI);
75 }
76 }
77 }
78
79 void testOp006(StringBuddy buffer, boolean validate) {
80 synchronized (buffer) {
81 if (validate) {
82 Assert.assertEquals(String.valueOf((float) 2.0), buffer.toString());
83 } else {
84 buffer.append((float) 2.0);
85 }
86 }
87 }
88
89 void testOp007(StringBuddy buffer, boolean validate) {
90 synchronized (buffer) {
91 if (validate) {
92 Assert.assertEquals(String.valueOf(0x7fffffff), buffer.toString());
93 } else {
94 buffer.append(Integer.MAX_VALUE);
95 }
96 }
97 }
98
99 void testOp008(StringBuddy buffer, boolean validate) {
100 synchronized (buffer) {
101 if (validate) {
102 Assert.assertEquals("42", buffer.toString());
103 } else {
104 buffer.append(42L);
105 }
106 }
107 }
108
109 void testOp009(StringBuddy buffer, boolean validate) {
110 String testString = "fetch me blocks, o' block provider";
111
112 synchronized (buffer) {
113 if (validate) {
114 Assert.assertEquals(testString, buffer.toString());
115 } else {
116 Assert.assertTrue("buffer too large: " + buffer.capacity(), buffer.capacity() < testString.length());
118
119 buffer.append(testString);
120 }
121 }
122 }
123
124 void testOp010(StringBuddy buffer, boolean validate) {
125 synchronized (buffer) {
126 if (validate) {
127 Assert.assertEquals("timmy", buffer.toString());
128 } else {
129 Assert.assertTrue("buffer too small: " + buffer.capacity(), buffer.capacity() > "timmy".length());
131 buffer.append("timmy");
132 }
133 }
134 }
135
136 void testOp011(StringBuddy buffer, boolean validate) {
137 synchronized (buffer) {
138 if (validate) {
139 Assert.assertEquals("timmy", buffer.toString());
140 } else {
141 buffer.append(new ToStringObject("timmy"));
142 }
143 }
144 }
145
146 void testOp012(StringBuddy buffer, boolean validate) {
147 synchronized (buffer) {
148 if (validate) {
149 Assert.assertEquals("0xcafebabe 0xdecafbad 0xdeadbeef", buffer.toString());
150 } else {
151 buffer.append(new StringBuffer ("0xcafebabe 0xdecafbad 0xdeadbeef"));
152 }
153 }
154 }
155
156 void testOp013(StringBuddy buffer, boolean validate) {
157 synchronized (buffer) {
158 if (validate) {
159 StringBuffer defaultStringBuffer = new StringBuffer ();
160 Assert.eval(buffer.capacity() == defaultStringBuffer.capacity());
161 } else {
162 }
164 }
165 }
166
167 void testOp014(StringBuddy buffer, boolean validate) {
168 synchronized (buffer) {
169 if (validate) {
170 Assert.assertEquals(78, buffer.capacity());
171 } else {
172 buffer.append("sdfjkhrkj2h34kj32h4jk2ejknb2r902jfuoinkjfb252l3u54hb2kl5hb2l35i235ou82h34ku234");
173 }
174 }
175 }
176
177 void testOp015(StringBuddy buffer, boolean validate) {
178 synchronized (buffer) {
179 if (validate) {
180 Assert.assertEquals(69, buffer.capacity());
181 } else {
182 }
184 }
185 }
186
187 void testOp016(StringBuddy buffer, boolean validate) {
188 synchronized (buffer) {
189 if (validate) {
190 Assert.assertEquals('z', buffer.charAt(7));
191 } else {
192 buffer.append("aaaaaa zebra");
193 }
194 }
195 }
196
197 void testOp017(StringBuddy buffer, boolean validate) {
198 synchronized (buffer) {
199 if (validate) {
200 Assert.assertEquals("toy", buffer.toString());
201 } else {
202 buffer.append("tommy");
203 buffer.delete(2, 4);
204 }
205 }
206 }
207
208 void testOp018(StringBuddy buffer, boolean validate) {
209 synchronized (buffer) {
210 if (validate) {
211 Assert.assertEquals("joebob", buffer.toString());
212 } else {
213 buffer.append("joe-bob");
214 buffer.deleteCharAt(3);
215 }
216 }
217 }
218
219 void testOp019(StringBuddy buffer, boolean validate) {
220 synchronized (buffer) {
221 if (validate) {
222 Assert.assertEquals(356, buffer.capacity());
223 } else {
224 buffer.ensureCapacity(356);
225 }
226 }
227 }
228
229 void testOp020(StringBuddy buffer, boolean validate) {
230 synchronized (buffer) {
231 if (validate) {
232 char[] chars = new char[buffer.length()];
233 buffer.getChars(0, buffer.length(), chars, 0);
234 Assert.eval(Arrays.equals(chars, "steve is fuzzy and blue".toCharArray()));
235 } else {
236 buffer.append("steve is fuzzy and blue");
237 }
238 }
239 }
240
241 void testOp021(StringBuddy buffer, boolean validate) {
242 synchronized (buffer) {
243 if (validate) {
244 Assert.assertEquals(5, buffer.indexOf("bam"));
245 } else {
246 buffer.append("wham bam");
247 }
248 }
249 }
250
251 void testOp022(StringBuddy buffer, boolean validate) {
252 synchronized (buffer) {
253 if (validate) {
254 Assert.assertEquals(33, buffer.indexOf("Java", 4));
255 } else {
256 buffer.append("why can't I add methods to null? Java sucks");
257 }
258 }
259 }
260
261 void testOp023(StringBuddy buffer, boolean validate) {
262 synchronized (buffer) {
263 if (validate) {
264 Assert.assertEquals("Terracotta's distributed StringBuffer will not change the face of software", buffer
265 .toString());
266 } else {
267 buffer.append("Terracotta's distributed StringBuffer will change the face of software");
268 buffer.insert(43, "not ".toCharArray(), 0, 4);
269 }
270 }
271 }
272
273 void testOp024(StringBuddy buffer, boolean validate) {
274 synchronized (buffer) {
275 if (validate) {
276 Assert.assertEquals("Q. Is Steve dead sexy? true", buffer.toString());
277 } else {
278 buffer.append("Q. Is Steve dead sexy? ");
279 buffer.insert(buffer.length(), true);
280 }
281 }
282 }
283
284 void testOp025(StringBuddy buffer, boolean validate) {
285 synchronized (buffer) {
286 if (validate) {
287 Assert.assertEquals("@55FACE", buffer.toString());
288 } else {
289 buffer.append("55FACE");
290 buffer.insert(0, '@');
291 }
292 }
293 }
294
295 void testOp026(StringBuddy buffer, boolean validate) {
296 synchronized (buffer) {
297 if (validate) {
298 Assert.assertEquals("Dude, where's my character array?", buffer.toString());
299 } else {
300 buffer.append("Dude, my character array?");
301 buffer.insert(6, "where's ".toCharArray());
302 }
303 }
304 }
305
306 void testOp027(StringBuddy buffer, boolean validate) {
307 synchronized (buffer) {
308 if (validate) {
309 Assert.assertEquals(String.valueOf(Double.MAX_VALUE), buffer.toString());
310 } else {
311 buffer.insert(0, Double.MAX_VALUE);
312 }
313 }
314 }
315
316 void testOp028(StringBuddy buffer, boolean validate) {
317 synchronized (buffer) {
318 if (validate) {
319 Assert.assertEquals(String.valueOf(Float.NaN), buffer.toString());
320 } else {
321 buffer.insert(0, Float.NaN);
322 }
323 }
324 }
325
326 void testOp029(StringBuddy buffer, boolean validate) {
327 synchronized (buffer) {
328 if (validate) {
329 Assert.assertEquals("123456789", buffer.toString());
330 } else {
331 buffer.insert(0, 123456789);
332 }
333 }
334 }
335
336 void testOp030(StringBuddy buffer, boolean validate) {
337 synchronized (buffer) {
338 if (validate) {
339 Assert.assertEquals("123456789123456789", buffer.toString());
340 } else {
341 buffer.insert(0, 123456789123456789L);
342 }
343 }
344 }
345
346 void testOp031(StringBuddy buffer, boolean validate) {
347 synchronized (buffer) {
348 if (validate) {
349 Assert.assertEquals("yer mom", buffer.toString());
350 } else {
351 buffer.insert(0, new ToStringObject("yer mom"));
352 }
353 }
354 }
355
356 void testOp032(StringBuddy buffer, boolean validate) {
357 synchronized (buffer) {
358 if (validate) {
359 Assert.assertEquals("chicks dig unix, but not macs", buffer.toString());
360 } else {
361 buffer.insert(0, "chicks dig unix, but not macs");
362 }
363 }
364 }
365
366 void testOp033(StringBuddy buffer, boolean validate) {
367 synchronized (buffer) {
368 if (validate) {
369 Assert.assertEquals(12, buffer.lastIndexOf("ball"));
370 } else {
371 buffer.append("ball1 ball2 ball3");
372 }
373 }
374 }
375
376 void testOp034(StringBuddy buffer, boolean validate) {
377 synchronized (buffer) {
378 if (validate) {
379 Assert.assertEquals(4, buffer.lastIndexOf("1", 4));
380 } else {
381 buffer.append("ball1 ball2 ball3");
382 }
383 }
384 }
385
386 void testOp035(StringBuddy buffer, boolean validate) {
387 synchronized (buffer) {
388 if (validate) {
389 Assert.assertEquals(0, buffer.length());
390 } else {
391 }
393 }
394 }
395
396 void testOp036(StringBuddy buffer, boolean validate) {
397 synchronized (buffer) {
398 if (validate) {
399 Assert.assertEquals(77, buffer.length());
400 } else {
401 buffer.append("I was in a HOT TUB! I was NORMAL! I was ITALIAN!! I enjoyed the EARTHQUAKE");
402 }
403 }
404 }
405
406 void testOp037(StringBuddy buffer, boolean validate) {
407 synchronized (buffer) {
408 if (validate) {
409 Assert.assertEquals("PUNK FUNK!! DISCO DUCK!! BIRTH CONTROL!!", buffer.toString());
410 } else {
411 buffer.append("PUNK ROCK!! DISCO DUCK!! BIRTH CONTROL!!");
412 buffer.replace(5, 8, "FUN");
413 }
414 }
415 }
416
417 void testOp038(StringBuddy buffer, boolean validate) {
418 synchronized (buffer) {
419 if (validate) {
420 Assert.assertEquals("StringBuffer is da bomb", buffer.toString());
421 } else {
422 buffer.append("YO");
423 buffer.replace(0, 2, "StringBuffer is da bomb");
424 }
425 }
426 }
427
428 void testOp039(StringBuddy buffer, boolean validate) {
429 synchronized (buffer) {
430 if (validate) {
431 Assert.assertEquals("redrum", buffer.toString());
432 } else {
433 buffer.append("murder");
434 buffer.reverse();
435 }
436 }
437 }
438
439 void testOp040(StringBuddy buffer, boolean validate) {
440 synchronized (buffer) {
441 if (validate) {
442 Assert.assertEquals("writing StringBuffer test rates about a 0 on a scale of 10", buffer.toString());
443 } else {
444 buffer.append("writing StringBuffer test rates about a 8 on a scale of 10");
445 buffer.setCharAt(40, '0');
446 }
447 }
448 }
449
450 void testOp041(StringBuddy buffer, boolean validate) {
451 synchronized (buffer) {
452 if (validate) {
453 Assert.assertEquals("no change", buffer.toString());
454 } else {
455 buffer.append("no change");
456 buffer.setLength(buffer.length());
457 }
458 }
459 }
460
461 void testOp042(StringBuddy buffer, boolean validate) {
462 synchronized (buffer) {
463 if (validate) {
464 Assert.assertEquals("changed? YES!", buffer.toString());
465 } else {
466 buffer.append("changed? NO");
467 buffer.setLength(9);
468 buffer.append("YES!");
469 }
470 }
471 }
472
473 void testOp043(StringBuddy buffer, boolean validate) {
474 synchronized (buffer) {
475 if (validate) {
476 Assert.assertEquals("almost", buffer.subSequence(0, 6));
478 Assert.assertEquals("almost", buffer.substring(0, 6));
479
480 Assert.assertEquals("tests", buffer.substring(20));
481 } else {
482 buffer.append("almost done writing tests");
483 }
484 }
485 }
486
487 void testOp044(StringBuddy buffer, boolean validate) {
488 synchronized (buffer) {
489 if (validate) {
490 StringBuffer compare = new StringBuffer ();
491 List vals = (List ) sharedMap.get("random vals " + buffer.getClass().getName());
492 for (Iterator i = vals.iterator(); i.hasNext();) {
493 Integer r = (Integer ) i.next();
494 compare.append(r.intValue());
495 compare.append(',');
496 }
497
498 Assert.assertEquals(compare.toString(), buffer.toString());
499 } else {
500 Random rnd = new SecureRandom ();
501 List vals = new ArrayList ();
502
503 final int n = 37 + rnd.nextInt(100);
504 for (int i = 0; i < n; i++) {
505 int r = rnd.nextInt();
506 vals.add(new Integer (r));
507 buffer.append(r);
508 buffer.append(',');
509 }
510
511 synchronized (sharedMap) {
512 sharedMap.put("random vals " + buffer.getClass().getName(), vals);
513 }
514 }
515 }
516 }
517
518 void testOp045(StringBuddy buffer, boolean validate) {
519 synchronized (buffer) {
520 String str = "these are the characters jerky";
522
523 if (validate) {
524 char[] compare = (char[]) sharedMap.get("getChars destination " + buffer.getClass());
525 Assert.assertTrue(Arrays.equals(str.toCharArray(), compare));
526 } else {
527 buffer.append(str);
528 char[] dest = new char[str.length()];
529 synchronized (sharedMap) {
530 sharedMap.put("getChars destination " + buffer.getClass(), dest);
531 }
532 buffer.getChars(0, buffer.length(), dest, 0);
533 }
534 }
535 }
536
537 void testOp046(StringBuddy buffer, boolean validate) {
538 synchronized (buffer) {
539 if (validate) {
540 Assert.assertEquals(String.valueOf(0x80000000), buffer.toString());
541 } else {
542 buffer.append(Integer.MIN_VALUE);
543 }
544 }
545 }
546
547 private static final String GET_CHARS_STRING = "make me slow";
548
549 void testOp047(StringBuddy buffer, boolean validate) {
550 synchronized (buffer) {
551
553 char[] target = (char[]) sharedMap.get("target array " + ClassUtils.getShortClassName(buffer.getClass()));
554
555 if (validate) {
556 Assert.assertTrue(Arrays.equals(GET_CHARS_STRING.toCharArray(), target));
557 } else {
558 buffer.append(GET_CHARS_STRING);
559 buffer.getChars(0, buffer.length(), target, 0);
560 }
561 }
562 }
563
564 void testOp048(StringBuddy buffer, boolean validate) {
565 synchronized (buffer) {
566
568 char[] target = (char[]) sharedMap.get("target array " + ClassUtils.getShortClassName(buffer.getClass()));
569
570 if (validate) {
571 Assert.assertTrue(Arrays.equals(GET_CHARS_STRING.toCharArray(), target));
572 } else {
573 StringBuffer unshared = new StringBuffer ();
574 unshared.append(GET_CHARS_STRING);
575 synchronized (target) {
576 unshared.getChars(0, unshared.length(), target, 0);
577 }
578 }
579 }
580 }
581
582 void testStringBuilderToStringPerf(StringBuddy buddy, boolean validate) {
583 if (!validate) return;
584 if (!(buddy instanceof StringBuilderBuddy)) { return; }
585
586 Random r = new Random ();
587 int rnd = r.nextInt();
588
589 StringBuilder builder = new StringBuilder ();
590
591 byte[] bytes = new byte[100];
592 r.nextBytes(bytes);
593 for (int i = 0; i < bytes.length; i++) {
594 builder.append(bytes[i]);
595 }
596
597 if (validate) {
598 for (int i = 0; i < 250000; i++) {
599 builder = xorChars(builder);
600 String string = builder.toString();
601
602 if (string.hashCode() == rnd) {
604 System.err.println();
605 }
606 }
607 }
608 }
609
610 private static StringBuilder xorChars(StringBuilder builder) {
611 char[] dest = new char[builder.length()];
612 builder.getChars(0, builder.length(), dest, 0);
613 for (int i = 0; i < dest.length; i++) {
614 dest[i] = (char) (dest[dest.length - 1 - i] ^ dest[i]);
615 }
616 return new StringBuilder (new String (dest));
617 }
618
619 protected Object getTestObject(String test) {
620 List l = new ArrayList ();
621 l.add(sharedMap.get("buffer"));
622 l.add(sharedMap.get("builder"));
623 return l.iterator();
624 }
625
626 protected void setupTestObject(String test) {
627 final StringBuddy buffer;
628 final StringBuddy builder;
629
630 if ("Op015".equals(test)) {
631 buffer = new StringBufferBuddy(new StringBuffer (69));
632 builder = new StringBuilderBuddy(new StringBuilder (69));
633 } else {
634 buffer = new StringBufferBuddy(new StringBuffer ());
635 builder = new StringBuilderBuddy(new StringBuilder ());
636 }
637
638 sharedMap.put("buffer", buffer);
639 sharedMap.put("builder", builder);
640
641 sharedMap.put("target array StringBuilderBuddy", new char[GET_CHARS_STRING.length()]);
642 sharedMap.put("target array StringBufferBuddy", new char[GET_CHARS_STRING.length()]);
643 }
644
645 private static final String BUFFER_TARGET_ARRAY = "buffer target array";
646 private static final String BUILDER_TARGET_ARRAY = "builder target array";
647
648 public static void visitL1DSOConfig(ConfigVisitor visitor, DSOClientConfigHelper config) {
649 String testClass = StringBufferTestApp.class.getName();
650 config.getOrCreateSpec(testClass);
651 String methodExpression = "* " + testClass + "*.*(..)";
652 config.addWriteAutolock(methodExpression);
653
654 config.addIncludePattern(StringBufferBuddy.class.getName());
655 config.addIncludePattern(StringBuilderBuddy.class.getName());
656
657 }
658
659 private static class ToStringObject {
660
661 private final String string;
662
663 ToStringObject(String string) {
664 super();
665 this.string = string;
666 }
667
668 public String toString() {
669 return this.string;
670 }
671
672 }
673
674 }
675 |
Popular Tags |
Java API By Example, From Geeks To Geeks.