Java > Open Source Codes > com > db4o > test > nativequery > analysis > BloatExprBuilderVisitorTestCase


1 /* Copyright (C) 2004 - 2006 db4objects Inc. http://www.db4o.com
2
3 This file is part of the db4o open source object database.
4
5 db4o is free software; you can redistribute it and/or modify it under
6 the terms of version 2 of the GNU General Public License as published
7 by the Free Software Foundation and as clarified by db4objects' GPL
8 interpretation policy, available at
9 http://www.db4o.com/about/company/legalpolicies/gplinterpretation/
10 Alternatively you can write to db4objects, Inc., 1900 S Norfolk Street,
11 Suite 350, San Mateo, CA 94403, USA.
12
13 db4o is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 package com.db4o.test.nativequery.analysis;
22
23 import EDU.purdue.cs.bloat.cfg.*;
24 import EDU.purdue.cs.bloat.file.*;
25 import EDU.purdue.cs.bloat.tree.*;
26
27 import com.db4o.nativequery.*;
28 import com.db4o.nativequery.analysis.*;
29 import com.db4o.nativequery.bloat.*;
30 import com.db4o.nativequery.expr.*;
31 import com.db4o.nativequery.expr.cmp.*;
32 import com.db4o.nativequery.expr.cmp.field.*;
33
34 import db4ounit.*;
35
36 class Base {
37     int id;
38     Integer idWrap;
39
40     public int getId() {
41         return id;
42     }
43
44     public Integer getIdWrapped() {
45         return idWrap;
46     }
47
48     public int getIdPlusOne() {
49         return id+1;
50     }
51 }
52
53 class Data extends Base {
54     boolean bool;
55     float value;
56     String name;
57     Data next;
58     int[] intArray;
59     Data[] objArray;
60     Boolean boolWrapper;
61     
62     public boolean getBool() {
63         return bool;
64     }
65     
66     public float getValue() {
67         return value;
68     }
69     public String getName() {
70         return name;
71     }
72     public Data getNext() {
73         return next;
74     }
75     
76     public boolean hasNext() {
77         return getNext()!=null;
78     }
79     
80     public void someMethod() {
81         System.out.println();
82     }
83 }
84
85 public class BloatExprBuilderVisitorTestCase implements TestCase,TestLifeCycle {
86     private static final String INT_WRAPPED_FIELDNAME = "idWrap";
87     private static final String BOOLEAN_FIELDNAME = "bool";
88     private static final String BOOLEAN_WRAPPED_FIELDNAME = "boolWrapper";
89     private static final String INT_FIELDNAME = "id";
90     private static final String FLOAT_FIELDNAME = "value";
91     private static final String DATA_FIELDNAME="next";
92     private static final String STRING_FIELDNAME = "name";
93     private final static boolean BOOLEAN_CMPVAL=false;
94     private final static int INT_CMPVAL=42;
95     private final static float FLOAT_CMPVAL=12.3f;
96     private final static String STRING_CMPVAL="Test";
97     private final static Integer INT_WRAPPER_CMPVAL=new Integer (INT_CMPVAL);
98     private final static Boolean BOOLEAN_WRAPPER_CMPVAL=Boolean.TRUE;
99     private final Integer intWrapperCmpVal=new Integer (INT_CMPVAL);
100     
101     private boolean boolMember=false;
102     private String stringMember="foo";
103     private int intMember=43;
104     private float floatMember=47.11f;
105     private int[] intArrayMember={};
106     private Data[] objArrayMember={};
107
108     private ClassFileLoader loader;
109     private BloatUtil bloatUtil;
110     
111     private int intMemberPlusOne() {
112         return intMember+1;
113     }
114
115     private int sum(int a,int b) {
116         return a+b;
117     }
118     
119     public void setUp() throws Exception {
120         loader=new ClassFileLoader();
121         bloatUtil=new BloatUtil(loader);
122     }
123     
124     // unconditional
125
126     boolean sampleTrue(Data data) {
127         return true;
128     }
129
130     public void testTrue() throws Exception {
131         Assert.areEqual(BoolConstExpression.TRUE,expression("sampleTrue"));
132     }
133
134     boolean sampleFalse(Data data) {
135         return false;
136     }
137
138     public void testFalse() throws Exception {
139         Assert.areEqual(BoolConstExpression.FALSE,expression("sampleFalse"));
140     }
141
142     // primitive identity
143
144     // boolean
145
146     boolean sampleFieldBooleanComp(Data data) {
147         return data.bool;
148     }
149
150     public void testFieldBooleanComp() throws Exception {
151         assertComparison("sampleFieldBooleanComp",BOOLEAN_FIELDNAME,Boolean.TRUE,ComparisonOperator.EQUALS,false);
152     }
153
154     boolean sampleFieldBooleanNotComp(Data data) {
155         return !data.bool;
156     }
157
158     public void testFieldBooleanNotComp() throws Exception {
159         assertComparison("sampleFieldBooleanNotComp",BOOLEAN_FIELDNAME,Boolean.FALSE,ComparisonOperator.EQUALS,false);
160     }
161
162     boolean sampleFieldBooleanEqualsComp(Data data) {
163         return data.bool==boolMember;
164     }
165
166     public void testFieldBooleanEqualsComp() throws Exception {
167         assertComparison("sampleFieldBooleanEqualsComp",BOOLEAN_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"boolMember","Z"),ComparisonOperator.EQUALS,false);
168     }
169
170     boolean sampleBooleanFieldEqualsComp(Data data) {
171         return boolMember==data.bool;
172     }
173
174     public void testBooleanFieldEqualsComp() throws Exception {
175         assertComparison("sampleBooleanFieldEqualsComp",BOOLEAN_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"boolMember","Z"),ComparisonOperator.EQUALS,false);
176     }
177
178     boolean sampleFieldBooleanNotEqualsComp(Data data) {
179         return data.bool!=boolMember;
180     }
181
182     public void testFieldBooleanNotEqualsComp() throws Exception {
183         assertComparison("sampleFieldBooleanNotEqualsComp",BOOLEAN_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"boolMember","Z"),ComparisonOperator.EQUALS,true);
184     }
185
186     boolean sampleBooleanFieldNotEqualsComp(Data data) {
187         return boolMember!=data.bool;
188     }
189
190     public void testBooleanFieldNotEqualsComp() throws Exception {
191         assertComparison("sampleBooleanFieldNotEqualsComp",BOOLEAN_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"boolMember","Z"),ComparisonOperator.EQUALS,true);
192     }
193
194     // int
195
196     boolean sampleFieldIntZeroEqualsComp(Data data) {
197         return data.id==0;
198     }
199
200     public void testFieldIntZeroEqualsComp() throws Exception {
201         assertComparison("sampleFieldIntZeroEqualsComp",INT_FIELDNAME,new Integer (0),ComparisonOperator.EQUALS,false);
202     }
203
204     boolean sampleFieldIntEqualsComp(Data data) {
205         return data.id==INT_CMPVAL;
206     }
207
208     public void testFieldIntEqualsComp() throws Exception {
209         assertComparison("sampleFieldIntEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,false);
210     }
211
212     boolean sampleFieldIntNotEqualsComp(Data data) {
213         return data.id!=INT_CMPVAL;
214     }
215
216     public void testFieldIntNotEqualsComp() throws Exception {
217         assertComparison("sampleFieldIntNotEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,true);
218     }
219
220     boolean sampleIntFieldEqualsComp(Data data) {
221         return INT_CMPVAL==data.id;
222     }
223
224     public void testIntFieldEqualsComp() throws Exception {
225         assertComparison("sampleIntFieldEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,false);
226     }
227
228     boolean sampleIntFieldNotEqualsComp(Data data) {
229         return INT_CMPVAL!=data.id;
230     }
231
232     public void testIntFieldNotEqualsComp() throws Exception {
233         assertComparison("sampleIntFieldNotEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,true);
234     }
235
236     // float
237
238     boolean sampleFieldFloatZeroEqualsComp(Data data) {
239         return data.value==0.0f;
240     }
241
242     public void testFieldFloatZeroEqualsComp() throws Exception {
243         assertComparison("sampleFieldFloatZeroEqualsComp",FLOAT_FIELDNAME,new Float (0.0f),ComparisonOperator.EQUALS,false);
244     }
245
246     boolean sampleFieldFloatZeroIntEqualsComp(Data data) {
247         return data.value==0;
248     }
249
250     public void testFieldFloatZeroIntEqualsComp() throws Exception {
251         assertComparison("sampleFieldFloatZeroIntEqualsComp",FLOAT_FIELDNAME,new Float (0.0f),ComparisonOperator.EQUALS,false);
252     }
253
254     boolean sampleFieldFloatEqualsComp(Data data) {
255         return data.value==FLOAT_CMPVAL;
256     }
257
258     public void testFieldFloatEqualsComp() throws Exception {
259         assertComparison("sampleFieldFloatEqualsComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.EQUALS,false);
260     }
261
262     boolean sampleFieldFloatNotEqualsComp(Data data) {
263         return data.value!=FLOAT_CMPVAL;
264     }
265
266     public void testFieldFloatNotEqualsComp() throws Exception {
267         assertComparison("sampleFieldFloatNotEqualsComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.EQUALS,true);
268     }
269
270     boolean sampleFloatFieldEqualsComp(Data data) {
271         return FLOAT_CMPVAL==data.value;
272     }
273
274     public void testFloatFieldEqualsComp() throws Exception {
275         assertComparison("sampleFloatFieldEqualsComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.EQUALS,false);
276     }
277
278     boolean sampleFloatFieldNotEqualsComp(Data data) {
279         return FLOAT_CMPVAL!=data.value;
280     }
281
282     public void testFloatFieldNotEqualsComp() throws Exception {
283         assertComparison("sampleFloatFieldNotEqualsComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.EQUALS,true);
284     }
285
286     // object identity
287
288     // TODO: nonsense, but need single roots for method calls
289 boolean sampleCandidateIdentity(Data data) {
290         return data==null;
291     }
292
293     public void _testCandidateIdentity() throws Exception {
294         assertComparison("sampleCandidateIdentity",new String []{},null,ComparisonOperator.EQUALS,false);
295     }
296
297     boolean sampleIdentityNullComp(Data data) {
298         return data.next==null;
299     }
300
301     public void testIdentityNullComp() throws Exception {
302         assertComparison("sampleIdentityNullComp",DATA_FIELDNAME,null,ComparisonOperator.EQUALS,false);
303     }
304
305     boolean sampleNotIdentityNullComp(Data data) {
306         return data.next!=null;
307     }
308
309     public void testNotIdentityNullComp() throws Exception {
310         assertComparison("sampleNotIdentityNullComp",DATA_FIELDNAME,null,ComparisonOperator.EQUALS,true);
311     }
312
313     // primitive unequal comparison
314
315     // int
316
317     boolean sampleFieldIntSmallerComp(Data data) {
318         return data.id<INT_CMPVAL;
319     }
320
321     public void testFieldIntSmallerComp() throws Exception {
322         assertComparison("sampleFieldIntSmallerComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.SMALLER,false);
323     }
324
325     boolean sampleFieldIntGreaterComp(Data data) {
326         return data.id>INT_CMPVAL;
327     }
328
329     public void testFieldIntGreaterComp() throws Exception {
330         assertComparison("sampleFieldIntGreaterComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.GREATER,false);
331     }
332
333     boolean sampleFieldIntSmallerEqualsComp(Data data) {
334         return data.id<=INT_CMPVAL;
335     }
336
337     public void testFieldIntSmallerEqualsComp() throws Exception {
338         assertComparison("sampleFieldIntSmallerEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.GREATER,true);
339     }
340
341     boolean sampleFieldIntGreaterEqualsComp(Data data) {
342         return data.id>=INT_CMPVAL;
343     }
344
345     public void testFieldIntGreaterEqualsComp() throws Exception {
346         assertComparison("sampleFieldIntGreaterEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.SMALLER,true);
347     }
348
349     boolean sampleIntFieldSmallerComp(Data data) {
350         return INT_CMPVAL<data.id;
351     }
352
353     public void testIntFieldSmallerComp() throws Exception {
354         assertComparison("sampleIntFieldSmallerComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.GREATER,false);
355     }
356
357     boolean sampleIntFieldGreaterComp(Data data) {
358         return INT_CMPVAL>data.id;
359     }
360
361     public void testIntFieldGreaterComp() throws Exception {
362         assertComparison("sampleIntFieldGreaterComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.SMALLER,false);
363     }
364
365     boolean sampleIntFieldSmallerEqualsComp(Data data) {
366         return INT_CMPVAL<=data.id;
367     }
368
369     public void testIntFieldSmallerEqualsComp() throws Exception {
370         assertComparison("sampleIntFieldSmallerEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.SMALLER,true);
371     }
372
373     boolean sampleIntFieldGreaterEqualsComp(Data data) {
374         return INT_CMPVAL>=data.id;
375     }
376
377     public void testIntFieldGreaterEqualsComp() throws Exception {
378         assertComparison("sampleIntFieldGreaterEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.GREATER,true);
379     }
380
381     boolean sampleFieldFloatSmallerComp(Data data) {
382         return data.value<FLOAT_CMPVAL;
383     }
384
385     public void testFieldFloatSmallerComp() throws Exception {
386         assertComparison("sampleFieldFloatSmallerComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.SMALLER,false);
387     }
388
389     boolean sampleFieldFloatGreaterComp(Data data) {
390         return data.value>FLOAT_CMPVAL;
391     }
392
393     public void testFieldFloatGreaterComp() throws Exception {
394         assertComparison("sampleFieldFloatGreaterComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.GREATER,false);
395     }
396
397     boolean sampleFieldFloatSmallerEqualsComp(Data data) {
398         return data.value<=FLOAT_CMPVAL;
399     }
400
401     public void testFieldFloatSmallerEqualsComp() throws Exception {
402         assertComparison("sampleFieldFloatSmallerEqualsComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.GREATER,true);
403     }
404
405     boolean sampleMemberIntSmallerEqualsComp(Data data) {
406         return intMember<=data.id;
407     }
408
409     public void testMemberIntSmallerEqualsComp() throws Exception {
410         assertComparison("sampleMemberIntSmallerEqualsComp",INT_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),ComparisonOperator.SMALLER,true);
411     }
412     
413     boolean sampleMemberFloatSmallerEqualsComp(Data data) {
414         return floatMember<=data.value;
415     }
416
417     public void testMemberFloatSmallerEqualsComp() throws Exception {
418         assertComparison("sampleMemberFloatSmallerEqualsComp",FLOAT_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"floatMember","F"),ComparisonOperator.SMALLER,true);
419     }
420     
421     // string equality
422
423     boolean sampleFieldStringEqualsComp(Data data) {
424         return data.name.equals(STRING_CMPVAL);
425     }
426
427     public void testFieldStringEqualsComp() throws Exception {
428         assertComparison("sampleFieldStringEqualsComp",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.EQUALS,false);
429     }
430
431     boolean sampleStringFieldEqualsComp(Data data) {
432         return STRING_CMPVAL.equals(data.name);
433     }
434
435     public void testStringFieldEqualsComp() throws Exception {
436         assertComparison("sampleStringFieldEqualsComp",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.EQUALS,false);
437     }
438     
439     // string-specific comparisons
440
441     boolean sampleFieldStringContains(Data data) {
442         return data.name.contains(STRING_CMPVAL);
443     }
444
445     public void testFieldStringContains() throws Exception {
446         assertComparison("sampleFieldStringContains",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.CONTAINS,false);
447     }
448
449     boolean sampleFieldStringContainsWrongWay(Data data) {
450         return STRING_CMPVAL.contains(data.name);
451     }
452
453     public void testFieldStringContainsWrongWay() throws Exception {
454         assertInvalid("sampleFieldStringContainsWrongWay");
455     }
456
457     boolean sampleFieldStringStartsWith(Data data) {
458         return data.name.startsWith(STRING_CMPVAL);
459     }
460
461     public void testFieldStringStartsWith() throws Exception {
462         assertComparison("sampleFieldStringStartsWith",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.STARTSWITH,false);
463     }
464
465     boolean sampleFieldStringStartsWithWrongWay(Data data) {
466         return STRING_CMPVAL.startsWith(data.name);
467     }
468
469     public void testFieldStringStartsWithWrongWay() throws Exception {
470         assertInvalid("sampleFieldStringStartsWithWrongWay");
471     }
472
473     boolean sampleFieldStringEndsWith(Data data) {
474         return data.name.endsWith(STRING_CMPVAL);
475     }
476
477     public void testFieldStringEndsWith() throws Exception {
478         assertComparison("sampleFieldStringEndsWith",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.ENDSWITH,false);
479     }
480
481     boolean sampleFieldStringEndsWithWrongWay(Data data) {
482         return STRING_CMPVAL.endsWith(data.name);
483     }
484
485     public void testFieldStringEndsWithWrongWay() throws Exception {
486         assertInvalid("sampleFieldStringEndsWithWrongWay");
487     }
488
489     // TODO: inconsistently fails on Windows, depending on test suite order?!? see COR-264
490 boolean sampleFieldStringToLowerCaseStartsWith(Data data) throws Exception {
491         return data.getName().toLowerCase().startsWith(STRING_CMPVAL);
492     }
493
494     public void _testFieldStringToLowerCaseStartsWith() throws Exception {
495         assertInvalid("sampleFieldStringToLowerCaseStartsWith");
496     }
497
498     // primitive wrapper equality
499
500     boolean sampleFieldBooleanWrapperEqualsComp(Data data) {
501         return data.boolWrapper.booleanValue();
502     }
503
504     public void testFieldBooleanWrapperEqualsComp() throws Exception {
505         assertComparison("sampleFieldBooleanWrapperEqualsComp",BOOLEAN_WRAPPED_FIELDNAME,Boolean.TRUE,ComparisonOperator.EQUALS,false);
506     }
507
508     boolean sampleFieldIntWrapperEqualsComp(Data data) {
509         return data.getIdWrapped().equals(intWrapperCmpVal);
510     }
511
512     public void testFieldIntWrapperEqualsComp() throws Exception {
513         assertComparison("sampleFieldIntWrapperEqualsComp",INT_WRAPPED_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"intWrapperCmpVal","java.lang.Integer"),ComparisonOperator.EQUALS,false);
514     }
515
516     boolean sampleIntWrapperFieldEqualsComp(Data data) {
517         return intWrapperCmpVal.equals(data.getIdWrapped());
518     }
519
520     public void testIntWrapperFieldEqualsComp() throws Exception {
521         assertComparison("sampleIntWrapperFieldEqualsComp",INT_WRAPPED_FIELDNAME,new FieldValue(PredicateFieldRoot.INSTANCE,"intWrapperCmpVal","java.lang.Integer"),ComparisonOperator.EQUALS,false);
522     }
523     
524     // descend into primitive wrapper
525
526     boolean sampleWrapperFieldValueIntSameComp(Data data) {
527         return data.getIdWrapped().intValue()==INT_CMPVAL;
528     }
529
530     public void testWrapperFieldValueIntSameComp() throws Exception {
531         assertComparison("sampleWrapperFieldValueIntSameComp",INT_WRAPPED_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,false);
532     }
533
534     boolean sampleNotValueBoolWrapperFieldSameComp(Data data) {
535         return data.boolWrapper.booleanValue();
536     }
537
538     public void testNotValueBoolWrapperFieldSameComp() throws Exception {
539         assertComparison("sampleNotValueBoolWrapperFieldSameComp",BOOLEAN_WRAPPED_FIELDNAME,Boolean.TRUE,ComparisonOperator.EQUALS,false);
540     }
541
542     // primitive field against wrapper
543
544     boolean sampleFieldWrapperIntSameComp(Data data) {
545         return data.getId()==INT_WRAPPER_CMPVAL.intValue();
546     }
547
548     public void testFieldWrapperIntSameComp() throws Exception {
549         assertComparison("sampleFieldWrapperIntSameComp",INT_FIELDNAME,new MethodCallValue(new FieldValue(new StaticFieldRoot(BloatExprBuilderVisitorTestCase.class.getName()),"INT_WRAPPER_CMPVAL",Integer .class.getName()),"intValue",new Class [0],new ComparisonOperand[0]),ComparisonOperator.EQUALS,false);
550     }
551
552     boolean sampleBoolWrapperFieldSameComp(Data data) {
553         return data.bool==BOOLEAN_WRAPPER_CMPVAL.booleanValue();
554     }
555
556     public void testBoolWrapperFieldSameComp() throws Exception {
557         assertComparison("sampleBoolWrapperFieldSameComp",BOOLEAN_FIELDNAME,new MethodCallValue(new FieldValue(new StaticFieldRoot(BloatExprBuilderVisitorTestCase.class.getName()),"BOOLEAN_WRAPPER_CMPVAL",Boolean .class.getName()),"booleanValue",new Class [0],new ComparisonOperand[0]),ComparisonOperator.EQUALS,false);
558     }
559
560     // wrapper comparison
561
562     boolean sampleFieldWrapperIntCompToEquals(Data data) {
563         return data.getIdWrapped().compareTo(INT_WRAPPER_CMPVAL)==0;
564     }
565
566     public void testFieldWrapperIntCompToEquals() throws Exception {
567         assertComparison("sampleFieldWrapperIntCompToEquals",INT_WRAPPED_FIELDNAME,new FieldValue(new StaticFieldRoot(BloatExprBuilderVisitorTestCase.class.getName()),"INT_WRAPPER_CMPVAL",Integer .class.getName()),ComparisonOperator.EQUALS,false);
568     }
569
570     boolean sampleFieldWrapperIntCompToNotEquals(Data data) {
571         return data.getIdWrapped().compareTo(INT_WRAPPER_CMPVAL)!=0;
572     }
573
574     public void testFieldWrapperIntCompToNotEquals() throws Exception {
575         assertComparison("sampleFieldWrapperIntCompToNotEquals",INT_WRAPPED_FIELDNAME,new FieldValue(new StaticFieldRoot(BloatExprBuilderVisitorTestCase.class.getName()),"INT_WRAPPER_CMPVAL",Integer .class.getName()),ComparisonOperator.EQUALS,true);
576     }
577
578     boolean sampleFieldWrapperIntCompToGreater(Data data) {
579         return data.getIdWrapped().compareTo(INT_WRAPPER_CMPVAL)>0;
580     }
581
582     public void testFieldWrapperIntCompToGreater() throws Exception {
583         assertComparison("sampleFieldWrapperIntCompToGreater",INT_WRAPPED_FIELDNAME,new FieldValue(new StaticFieldRoot(BloatExprBuilderVisitorTestCase.class.getName()),"INT_WRAPPER_CMPVAL",Integer .class.getName()),ComparisonOperator.GREATER,false);
584     }
585
586     boolean sampleFieldWrapperIntCompToLE(Data data) {
587         return data.getIdWrapped().compareTo(INT_WRAPPER_CMPVAL)<=0;
588     }
589
590     public void testFieldWrapperIntCompToLE() throws Exception {
591         assertComparison("sampleFieldWrapperIntCompToLE",INT_WRAPPED_FIELDNAME,new FieldValue(new StaticFieldRoot(BloatExprBuilderVisitorTestCase.class.getName()),"INT_WRAPPER_CMPVAL",Integer .class.getName()),ComparisonOperator.GREATER,true);
592     }
593
594     //static member comparison
595
596     boolean sampleStaticFieldIntWrapperEqualsComp(Data data) {
597         return data.getIdWrapped().equals(INT_WRAPPER_CMPVAL);
598     }
599
600     public void testStaticFieldIntWrapperEqualsComp() throws Exception {
601         //assertInvalid("sampleStaticFieldIntWrapperEqualsComp");
602 assertComparison("sampleStaticFieldIntWrapperEqualsComp",INT_WRAPPED_FIELDNAME,new FieldValue(new StaticFieldRoot(getClass().getName()),"INT_WRAPPER_CMPVAL","java.lang.Integer"),ComparisonOperator.EQUALS,false);
603     }
604
605     boolean sampleStaticIntWrapperFieldEqualsComp(Data data) {
606         return INT_WRAPPER_CMPVAL.equals(data.getIdWrapped());
607     }
608
609     public void testStaticIntWrapperFieldEqualsComp() throws Exception {
610         //assertInvalid("sampleStaticIntWrapperFieldEqualsComp");
611 assertComparison("sampleStaticIntWrapperFieldEqualsComp",INT_WRAPPED_FIELDNAME,new FieldValue(new StaticFieldRoot(getClass().getName()),"INT_WRAPPER_CMPVAL","java.lang.Integer"),ComparisonOperator.EQUALS,false);
612     }
613     
614     // getter
615
616     boolean sampleGetterBoolComp(Data data) {
617         return data.getBool();
618     }
619
620     public void testGetterBoolComp() throws Exception {
621         assertComparison("sampleGetterBoolComp",BOOLEAN_FIELDNAME,Boolean.TRUE,ComparisonOperator.EQUALS,false);
622     }
623
624     // TODO fails when run via Ant?!?
625 boolean sampleBoolGetterNotEqualsComp(Data data) {
626         return BOOLEAN_CMPVAL!=data.getBool();
627     }
628
629     public void _testBoolGetterNotEqualsComp() throws Exception {
630         assertComparison("sampleBoolGetterNotEqualsComp",BOOLEAN_FIELDNAME,Boolean.valueOf(!BOOLEAN_CMPVAL),ComparisonOperator.EQUALS,false);
631     }
632
633     boolean sampleGetterIntEqualsComp(Data data) {
634         return data.getId()==INT_CMPVAL;
635     }
636
637     public void testGetterIntEqualsComp() throws Exception {
638         assertComparison("sampleGetterIntEqualsComp",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,false);
639     }
640
641     boolean sampleGetterStringEqualsComp(Data data) {
642         return data.getName().equals(STRING_CMPVAL);
643     }
644
645     public void testGetterStringEqualsComp() throws Exception {
646         assertComparison("sampleGetterStringEqualsComp",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.EQUALS,false);
647     }
648
649     boolean sampleGetterFloatSmallerComp(Data data) {
650         return data.getValue()<FLOAT_CMPVAL;
651     }
652
653     public void testGetterFloatSmallerComp() throws Exception {
654         assertComparison("sampleGetterFloatSmallerComp",FLOAT_FIELDNAME,new Float (FLOAT_CMPVAL),ComparisonOperator.SMALLER,false);
655     }
656
657     // field cascade
658
659     boolean sampleCascadeFieldStringEqualsComp(Data data) {
660         return data.next.name.equals(STRING_CMPVAL);
661     }
662
663     public void testCascadeFieldStringEqualsComp() throws Exception {
664         assertComparison("sampleCascadeFieldStringEqualsComp",new String []{DATA_FIELDNAME,STRING_FIELDNAME},STRING_CMPVAL,ComparisonOperator.EQUALS,false);
665     }
666
667     boolean sampleGetterCascadeIntFieldEqualsComp(Data data) {
668         return INT_CMPVAL==data.getNext().getId();
669     }
670
671     public void testGetterCascadeIntFieldEqualsComp() throws Exception {
672         assertComparison("sampleGetterCascadeIntFieldEqualsComp",new String []{DATA_FIELDNAME,INT_FIELDNAME},new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,false);
673     }
674
675     boolean sampleCascadeStringFieldEqualsComp(Data data) {
676         return STRING_CMPVAL.equals(data.next.name);
677     }
678
679     public void testCascadeStringFieldEqualsComp() throws Exception {
680         assertComparison("sampleCascadeStringFieldEqualsComp",new String []{DATA_FIELDNAME,STRING_FIELDNAME},STRING_CMPVAL,ComparisonOperator.EQUALS,false);
681     }
682
683     boolean sampleGetterCascadeStringFieldEqualsComp(Data data) {
684         return STRING_CMPVAL.equals(data.getNext().getName());
685     }
686
687     public void testGetterCascadeStringFieldEqualsComp() throws Exception {
688         assertComparison("sampleGetterCascadeStringFieldEqualsComp",new String []{DATA_FIELDNAME,STRING_FIELDNAME},STRING_CMPVAL,ComparisonOperator.EQUALS,false);
689     }
690
691     boolean sampleGetterCascadeFloatFieldGreaterEqualsComp(Data data) {
692         return FLOAT_CMPVAL>=data.getNext().getValue();
693     }
694
695     public void testGetterCascadeFloatFieldGreaterEqualsComp() throws Exception {
696         assertComparison("sampleGetterCascadeFloatFieldGreaterEqualsComp",new String []{DATA_FIELDNAME,FLOAT_FIELDNAME},new Float (FLOAT_CMPVAL),ComparisonOperator.GREATER,true);
697     }
698
699     // member field comparison
700
701     boolean sampleFieldIntMemberEqualsComp(Data data) {
702         return data.getId()==intMember;
703     }
704
705     public void testFieldIntMemberEqualsComp() throws Exception {
706         assertComparison("sampleFieldIntMemberEqualsComp",new String []{INT_FIELDNAME},new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),ComparisonOperator.EQUALS,false);
707     }
708
709     boolean sampleIntMemberFieldGreaterEqualsComp(Data data) {
710         return intMember>=data.getId();
711     }
712
713     public void testIntMemberFieldGreaterEqualsComp() throws Exception {
714         assertComparison("sampleIntMemberFieldGreaterEqualsComp",new String []{INT_FIELDNAME},new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),ComparisonOperator.GREATER,true);
715     }
716
717     boolean sampleFieldStringMemberEqualsComp(Data data) {
718         return data.getName().equals(stringMember);
719     }
720
721     public void testFieldStringMemberEqualsComp() throws Exception {
722         assertComparison("sampleFieldStringMemberEqualsComp",new String []{STRING_FIELDNAME},new FieldValue(PredicateFieldRoot.INSTANCE,"stringMember","java.lang.String"),ComparisonOperator.EQUALS,false);
723     }
724
725     boolean sampleFieldFloatMemberNotEqualsComp(Data data) {
726         return data.getValue()!=floatMember;
727     }
728
729     public void testFieldFloatMemberNotEqualsComp() throws Exception {
730         assertComparison("sampleFieldFloatMemberNotEqualsComp",new String []{FLOAT_FIELDNAME},new FieldValue(PredicateFieldRoot.INSTANCE,"floatMember","F"),ComparisonOperator.EQUALS,true);
731     }
732
733     boolean sampleFloatMemberFieldNotEqualsComp(Data data) {
734         return floatMember!=data.getValue();
735     }
736
737     public void testFloatMemberFieldNotEqualsComp() throws Exception {
738         assertComparison("sampleFloatMemberFieldNotEqualsComp",new String []{FLOAT_FIELDNAME},new FieldValue(PredicateFieldRoot.INSTANCE,"floatMember","F"),ComparisonOperator.EQUALS,true);
739     }
740
741     // negations
742
743     boolean sampleStringNot(Data data) {
744         return !STRING_CMPVAL.equals(data.name);
745     }
746     
747     public void testStringNot() throws Exception {
748         assertComparison("sampleStringNot",STRING_FIELDNAME,STRING_CMPVAL,ComparisonOperator.EQUALS,true);
749     }
750
751     boolean sampleIntEqualsNot(Data data) {
752         return !(data.id==INT_CMPVAL);
753     }
754     
755     public void testIntEqualsNot() throws Exception {
756         assertComparison("sampleIntEqualsNot",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,true);
757     }
758
759     boolean sampleIntNotEqualsNot(Data data) {
760         return !(data.id!=INT_CMPVAL);
761     }
762     
763     public void testIntNotEqualsNot() throws Exception {
764         assertComparison("sampleIntNotEqualsNot",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.EQUALS,false);
765     }
766
767     boolean sampleIntGreaterNot(Data data) {
768         return !(data.id>INT_CMPVAL);
769     }
770     
771     public void testIntGreaterNot() throws Exception {
772         assertComparison("sampleIntGreaterNot",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.GREATER,true);
773     }
774
775     boolean sampleIntSmallerEqualsNot(Data data) {
776         return !(data.id<=INT_CMPVAL);
777     }
778     
779     public void testIntSmallerEqualsNot() throws Exception {
780         assertComparison("sampleIntSmallerEqualsNot",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.GREATER,false);
781     }
782
783     boolean sampleIntNotNot(Data data) {
784         return !(!(data.id<INT_CMPVAL));
785     }
786     
787     public void testIntNotNot() throws Exception {
788         assertComparison("sampleIntNotNot",INT_FIELDNAME,new Integer (INT_CMPVAL),ComparisonOperator.SMALLER,false);
789     }
790
791     // conjunctions
792
793     boolean sampleBoolBoolAnd(Data data) {
794         return !data.getBool()&&data.getBool();
795     }
796     
797     public void testBoolBoolAnd() throws Exception {
798         AndExpression expr = (AndExpression) expression("sampleBoolBoolAnd");
799         assertComparison(expr.left(),new String []{BOOLEAN_FIELDNAME},Boolean.FALSE,ComparisonOperator.EQUALS,false);
800         assertComparison(expr.right(),new String []{BOOLEAN_FIELDNAME},Boolean.TRUE,ComparisonOperator.EQUALS,false);
801     }
802
803     boolean sampleIntIntAnd(Data data) {
804         return (data.id>42)&&(data.id<100);
805     }
806     
807     public void testIntIntAnd() throws Exception {
808         AndExpression expr = (AndExpression) expression("sampleIntIntAnd");
809         assertComparison(expr.left(),new String []{"id"},new Integer (42),ComparisonOperator.GREATER,false);
810         assertComparison(expr.right(),new String []{"id"},new Integer (100),ComparisonOperator.SMALLER,false);
811     }
812
813     boolean sampleStringIntOr(Data data) {
814         return (data.name.equals("Foo"))||(data.id==42);
815     }
816
817     public void testStringIntOr() throws Exception {
818         OrExpression expr = (OrExpression)expression("sampleStringIntOr");
819         assertComparison(expr.left(),new String []{"name"},"Foo",ComparisonOperator.EQUALS,false);
820         ComparisonExpression right=(ComparisonExpression)expr.right();
821         assertComparison(right,new String []{"id"},new Integer (42),ComparisonOperator.EQUALS,false);
822     }
823
824     boolean sampleIntStringNotOr(Data data) {
825         return !((data.id==42)||(data.name.equals("Foo")));
826     }
827
828     public void testIntStringNotOr() throws Exception {
829         AndExpression expr = (AndExpression)expression("sampleIntStringNotOr");
830         assertComparison(expr.left(),new String []{"id"},new Integer (42),ComparisonOperator.EQUALS,true);
831         assertComparison(expr.right(),new String []{"name"},"Foo",ComparisonOperator.EQUALS,true);
832     }
833
834     boolean sampleOuterOrInnerAnd(Data data) {
835         return (data.id==42)&&(data.getName().equals("Bar"))||(data.name.equals("Foo"));
836     }
837
838     public void testOuterOrInnerAnd() throws Exception {
839         OrExpression expr = (OrExpression)expression("sampleOuterOrInnerAnd");
840         assertComparison(expr.left(),new String []{"name"},"Foo",ComparisonOperator.EQUALS,false);
841         AndExpression andExpr=(AndExpression)expr.right();
842         assertComparison(andExpr.left(),new String []{"id"},new Integer (42),ComparisonOperator.EQUALS,false);
843         assertComparison(andExpr.right(),new String []{"name"},"Bar",ComparisonOperator.EQUALS,false);
844     }
845
846     boolean sampleOuterAndInnerOr(Data data) {
847         return ((data.id<42)||(data.getName().equals("Bar")))&&(data.getId()>10);
848     }
849
850     public void testOuterAndInnerOr() throws Exception {
851         AndExpression expr = (AndExpression)expression("sampleOuterAndInnerOr");
852         assertComparison(expr.left(),new String []{"id"},new Integer (10),ComparisonOperator.GREATER,false);
853         OrExpression orExpr=(OrExpression)expr.right();
854         assertComparison(orExpr.left(),new String []{"id"},new Integer (42),ComparisonOperator.SMALLER,false);
855         assertComparison(orExpr.right(),new String []{"name"},"Bar",ComparisonOperator.EQUALS,false);
856     }
857
858     // arithmetic
859
860     boolean sampleSanityIntAdd(Data data) {
861         return data.id<INT_CMPVAL+INT_CMPVAL; // compile time constant!
862 }
863     
864     public void testSanityIntAdd() throws Exception {
865         assertComparison("sampleSanityIntAdd",INT_FIELDNAME,new Integer (2*INT_CMPVAL),ComparisonOperator.SMALLER,false);
866     }
867
868     boolean sampleSanityIntMultiply(Data data) {
869         return data.id<2*INT_CMPVAL; // compile time constant!
870 }
871     
872     public void testSanityIntMultiply() throws Exception {
873         assertComparison("sampleSanityIntMultiply",INT_FIELDNAME,new Integer (2*INT_CMPVAL),ComparisonOperator.SMALLER,false);
874     }
875
876     boolean sampleMemberIntMultiply(Data data) {
877         return data.id<2*intMember;
878     }
879     
880     public void testMemberIntMultiply() throws Exception {
881         assertComparison("sampleMemberIntMultiply",INT_FIELDNAME,new ArithmeticExpression(new ConstValue(new Integer (2)),new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),ArithmeticOperator.MULTIPLY),ComparisonOperator.SMALLER,false);
882     }
883
884     boolean sampleIntMemberDivide(Data data) {
885         return data.id>intMember/2;
886     }
887     
888     public void testIntMemberDivide() throws Exception {
889         assertComparison("sampleIntMemberDivide",INT_FIELDNAME,new ArithmeticExpression(new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),new ConstValue(new Integer (2)),ArithmeticOperator.DIVIDE),ComparisonOperator.GREATER,false);
890     }
891
892     boolean sampleIntMemberMemberAdd(Data data) {
893         return data.id==intMember+intMember;
894     }
895     
896     public void testIntMemberMemberAdd() throws Exception {
897         assertComparison("sampleIntMemberMemberAdd",INT_FIELDNAME,new ArithmeticExpression(new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),ArithmeticOperator.ADD),ComparisonOperator.EQUALS,false);
898     }
899
900     // array access
901
902     boolean sampleIntArrayAccess(Data data) {
903         return data.id==intArrayMember[0];
904     }
905
906     public void testIntArrayAccess() throws Exception {
907         assertComparison("sampleIntArrayAccess","id",new ArrayAccessValue(new FieldValue(PredicateFieldRoot.INSTANCE,"intArrayMember","[I"),new ConstValue(new Integer (0))),ComparisonOperator.EQUALS,false);
908     }
909
910     boolean sampleObjectArrayAccess(Data data) {
911         return data.next.id==objArrayMember[0].id;
912     }
913
914     public void testObjectArrayAccess() throws Exception {
915         assertComparison("sampleObjectArrayAccess",new String []{"next","id"},new FieldValue(new ArrayAccessValue(new FieldValue(PredicateFieldRoot.INSTANCE,"objArrayMember","[L"+Data.class.getName()+";"),new ConstValue(new Integer (0))),"id","I"),ComparisonOperator.EQUALS,false);
916     }
917
918     
919     // non-candidate method calls
920
921     boolean sampleIntAddInPredicateMethod(Data data) {
922         return data.getId()==intMemberPlusOne();
923     }
924
925     public void testIntAddInPredicateMethod() throws Exception {
926         assertComparison("sampleIntAddInPredicateMethod",INT_FIELDNAME,new MethodCallValue(PredicateFieldRoot.INSTANCE,"intMemberPlusOne",new Class []{},new ComparisonOperand[]{}),ComparisonOperator.EQUALS,false);
927     }
928
929     boolean sampleStaticMethodCall(Data data) {
930         return data.id==Integer.parseInt(stringMember);
931     }
932
933     public void testStaticMethodCall() throws Exception {
934         assertComparison("sampleStaticMethodCall",INT_FIELDNAME,new MethodCallValue(new StaticFieldRoot(Integer .class.getName()),"parseInt",new Class []{String .class},new ComparisonOperand[]{new FieldValue(PredicateFieldRoot.INSTANCE,"stringMember","java.lang.String")}),ComparisonOperator.EQUALS,false);
935     }
936
937     boolean sampleTwoParamMethodCall(Data data) {
938         return data.id==sum(intMember,0);
939     }
940
941     public void testTwoParamMethodCall() throws Exception {
942         assertComparison("sampleTwoParamMethodCall",INT_FIELDNAME,new MethodCallValue(PredicateFieldRoot.INSTANCE,"sum",new Class []{Integer.TYPE,Integer.TYPE},new ComparisonOperand[]{new FieldValue(PredicateFieldRoot.INSTANCE,"intMember","I"),new ConstValue(new Integer (0))}),ComparisonOperator.EQUALS,false);
943     }
944
945     // not applicable
946
947     // TODO: definitely applicable - fix!
948 boolean sampleInvalidOtherMemberEqualsComp(Data data) {
949         return stringMember.equals(STRING_CMPVAL);
950     }
951
952     public void testInvalidOtherMemberEqualsComp() throws Exception {
953         assertInvalid("sampleInvalidOtherMemberEqualsComp");
954     }
955
956     boolean sampleInvalidOtherMemberSameComp(Data data) {
957         return stringMember==STRING_CMPVAL;
958     }
959
960     public void testInvalidOtherMemberSameComp() throws Exception {
961         assertInvalid("sampleInvalidOtherMemberSameComp");
962     }
963
964     boolean sampleInvalidCandidateMemberArithmetic(Data data) {
965         return data.id-1==INT_CMPVAL;
966     }
967
968     public void testInvalidCandidateMemberArithmetic() throws Exception {
969         assertInvalid("sampleInvalidCandidateMemberArithmetic");
970     }
971
972     boolean sampleInvalidTemporaryStorage(Data data) {
973         int val=INT_CMPVAL-1;
974         return data.id==val;
975     }
976
977     public void testInvalidTemporaryStorage() throws Exception {
978         assertInvalid("sampleInvalidTemporaryStorage");
979     }
980
981     boolean sampleInvalidMethodCall(Data data) {
982         data.someMethod();
983         return true;
984     }
985
986     public void testInvalidMethodCall() throws Exception {
987         assertInvalid("sampleInvalidMethodCall");
988     }
989
990     boolean sampleInvalidConstructorCall(Data data) {
991         return data.next==new Data().getNext();
992     }
993
994     public void testInvalidConstructorCall() throws Exception {
995         assertInvalid("sampleInvalidConstructorCall");
996     }
997
998     boolean sampleSimpleObjectComparison(Data data) {
999         return data.equals(new Data());
1000    }
1001
1002    public void testSimpleObjectComparison() throws Exception {
1003        assertInvalid("sampleSimpleObjectComparison");
1004    }
1005
1006    boolean sampleSimpleFieldObjectComparison(Data data) {
1007        return data.next.equals(new Data());
1008    }
1009
1010    public void testSimpleFieldObjectComparison() throws Exception {
1011        assertInvalid("sampleSimpleFieldObjectComparison");
1012    }
1013
1014    boolean sampleSimpleFieldObjectIdentityComparison(Data data) {
1015        return data.next.equals(data.next);
1016    }
1017
1018    public void testSimpleFieldObjectIdentityComparison() throws Exception {
1019        assertInvalid("sampleSimpleFieldObjectIdentityComparison");
1020    }
1021
1022    boolean sampleCandEqualsNullComparison(Data data) {
1023        return data.equals(null);
1024    }
1025
1026    public void testCandEqualsNullComparison() throws Exception {
1027        assertInvalid("sampleCandEqualsNullComparison");
1028    }
1029
1030    boolean sampleCandIdentityObjectComparison(Data data) {
1031        return data.equals(data);
1032    }
1033
1034    public void testCandIdentityObjectComparison() throws Exception {
1035        assertInvalid("sampleCandIdentityObjectComparison");
1036    }
1037
1038    boolean sampleRecursiveCall(Data data) {
1039        return sampleRecursiveCall(data);
1040    }
1041
1042    public void testRecursiveCall() throws Exception {
1043        assertInvalid("sampleRecursiveCall");
1044    }
1045
1046    boolean sampleCandidateIntArrayAccess(Data data) {
1047        return data.intArray[0]==0;
1048    }
1049
1050    public void testCandidateIntArrayAccess() throws Exception {
1051        assertInvalid("sampleCandidateIntArrayAccess");
1052    }
1053
1054    boolean sampleCandidateObjectArrayAccess(Data data) {
1055        return data.objArray[0].id==0;
1056    }
1057
1058    public void testCandidateObjectArrayAccess() throws Exception {
1059        assertInvalid("sampleCandidateObjectArrayAccess");
1060    }
1061
1062    boolean sampleCandidateParamMethodCall(Data data) {
1063        return data.id==sum(data.id,0);
1064    }
1065
1066    public void testCandidateParamMethodCall() throws Exception {
1067        assertInvalid("sampleCandidateParamMethodCall");
1068    }
1069
1070    boolean sampleCandidateParamStaticMethodCall(Data data) {
1071        return data.id==Integer.parseInt(data.name);
1072    }
1073
1074    public void testCandidateParamStaticMethodCall() throws Exception {
1075        assertInvalid("sampleCandidateParamStaticMethodCall");
1076    }
1077
1078    boolean sampleSwitch(Data data) {
1079        switch(data.id) {
1080            case 0:
1081            case 1:
1082            case 2:
1083            case 4:
1084                return true;
1085            default:
1086                return false;
1087        }
1088    }
1089
1090    public void testSwitch() throws Exception {
1091        assertInvalid("sampleSwitch");
1092    }
1093
1094    boolean sampleStringAppend(Data data) {
1095        return data.name.equals(stringMember+"X");
1096    }
1097
1098    public void testStringAppend() throws Exception {
1099        assertInvalid("sampleStringAppend");
1100    }
1101
1102    boolean sampleExternalWrapperComp(Data data) {
1103        return INT_WRAPPER_CMPVAL.compareTo(INT_WRAPPER_CMPVAL)==0;
1104    }
1105
1106    public void testExternalWrapperComp() throws Exception {
1107        assertInvalid("sampleExternalWrapperComp");
1108    }
1109
1110    boolean sampleNotApplicableIfCondition(Data data) {
1111        if(stringMember.equals("XXX")) {
1112            return data.getName().equals(STRING_CMPVAL);
1113        }
1114        else {
1115            return false;
1116        }
1117    }
1118
1119    public void testNotApplicableIfCondition() throws Exception {
1120        assertInvalid("sampleNotApplicableIfCondition");
1121    }
1122
1123    boolean sampleNotApplicableIfStringAppendCondition(Data data) {
1124        if(stringMember.equals(stringMember+"X")) {
1125            return data.getName().equals(STRING_CMPVAL);
1126        }
1127        else {
1128            return false;
1129        }
1130    }
1131
1132    public void testNotApplicableIfStringAppendCondition() throws Exception {
1133        assertInvalid("sampleNotApplicableIfStringAppendCondition");
1134    }
1135    
1136    // internal
1137
1138    private void assertComparison(String methodName, String fieldName,Object value, ComparisonOperator op,boolean negated) {
1139        assertComparison(methodName,new String []{fieldName},value,op,negated);
1140    }
1141
1142    private void assertComparison(String methodName, String [] fieldNames,Object value, ComparisonOperator op,boolean negated) {
1143        try {
1144            Expression expr = expression(methodName);
1145            assertComparison(expr, fieldNames, value, op, negated);
1146        } catch (ClassNotFoundException e) {
1147            Assert.fail(e.getMessage());
1148        }
1149    }
1150
1151    private void assertComparison(Expression expr, String [] fieldNames, Object value, ComparisonOperator op, boolean negated) {
1152        if(negated) {
1153            NotExpression notExpr=(NotExpression)expr;
1154            expr=notExpr.expr();
1155        }
1156        ComparisonExpression cmpExpr=(ComparisonExpression)expr;
1157        Assert.areEqual(op, cmpExpr.op());
1158        ComparisonOperand curop=cmpExpr.left();
1159        for(int foundFieldIdx=fieldNames.length-1;foundFieldIdx>=0;foundFieldIdx--) {
1160            FieldValue fieldValue=(FieldValue)curop;
1161            Assert.areEqual(fieldNames[foundFieldIdx], fieldValue.fieldName());
1162            curop=fieldValue.parent();
1163        }
1164        Assert.areEqual(CandidateFieldRoot.INSTANCE,curop);
1165        ComparisonOperand right = cmpExpr.right();
1166        if(right instanceof ConstValue) {
1167            Assert.areEqual(value, ((ConstValue) right).value());
1168            return;
1169        }
1170        Assert.areEqual(value,right);
1171    }
1172
1173    private void assertInvalid(String methodName) throws ClassNotFoundException {
1174        Expression expression = expression(methodName);
1175        if(expression!=null) {
1176            System.err.println(expression);
1177        }
1178        Assert.isNull(expression);
1179    }
1180    
1181    private Expression expression(String methodName) throws ClassNotFoundException {
1182        BloatExprBuilderVisitor visitor = new BloatExprBuilderVisitor(bloatUtil);
1183        FlowGraph flowGraph=bloatUtil.flowGraph(getClass().getName(),methodName);
1184        if(NQDebug.LOG) {
1185            flowGraph.visit(new PrintVisitor());
1186// flowGraph.visit(new TreeStructureVisitor());
1187 }
1188        flowGraph.visit(visitor);
1189        Expression expr = visitor.expression();
1190        if(NQDebug.LOG) {
1191            System.out.println(expr);
1192        }
1193        return expr;
1194    }
1195
1196    public void tearDown() throws Exception {
1197    }
1198    
1199    public static void main(String [] args) throws Exception {
1200        java.lang.reflect.Method method=BloatExprBuilderVisitorTestCase.class.getMethod("testFieldWrapperIntCompToEquals",new Class []{});
1201        Test[] tests={
1202                new TestMethod(new BloatExprBuilderVisitorTestCase(),method)
1203        };
1204        TestSuite suite=new TestSuite(tests);
1205        new TestRunner(suite).run();
1206    }
1207}
1208

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags