KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mmbase > storage > search > implementation > BasicFieldCompareConstraintTest


1 package org.mmbase.storage.search.implementation;
2
3 import junit.framework.*;
4 import org.mmbase.module.core.*;
5 import org.mmbase.module.corebuilders.FieldDefs;
6 import org.mmbase.storage.search.*;
7
8 /**
9  * JUnit tests.
10  *
11  * @author Rob van Maris
12  * @version $Revision: 1.3 $
13  */

14 public class BasicFieldCompareConstraintTest extends TestCase {
15     
16     private final static String JavaDoc BUILDER_NAME = "images";
17     private final static String JavaDoc FIELD_NAME1 = "title";
18     private final static String JavaDoc FIELD_NAME2 = "number";
19
20     /** Test instance 1 (string field). */
21     private BasicFieldCompareConstraint instance1 = null;
22     
23     /** Test instance 2 (integer field). */
24     private BasicFieldCompareConstraint instance2 = null;
25     
26     /** MMBase instance. */
27     private MMBase mmbase = null;
28     
29     /** Field instance 1 (string field). */
30     private StepField field1 = null;
31     
32     /** Field instance 2 (integer field). */
33     private StepField field2 = null;
34     
35     /** Builder example. */
36     private MMObjectBuilder builder = null;
37     
38     /** FieldDefs example. */
39     private FieldDefs fieldDefs = null;
40     
41     public BasicFieldCompareConstraintTest(java.lang.String JavaDoc testName) {
42         super(testName);
43     }
44     
45     public static void main(java.lang.String JavaDoc[] args) {
46         junit.textui.TestRunner.run(suite());
47     }
48     
49     /**
50      * Sets up before each test.
51      */

52     public void setUp() throws Exception JavaDoc {
53         MMBaseContext.init();
54         mmbase = MMBase.getMMBase();
55         builder = mmbase.getBuilder(BUILDER_NAME);
56         Step step = new BasicStep(builder);
57         
58         // Create instance 1 (string field).
59
fieldDefs = builder.getField(FIELD_NAME1);
60         field1 = new BasicStepField(step, fieldDefs);
61         instance1 = new BasicFieldCompareConstraint(field1);
62         
63         // Create instance 2 (integer field).
64
fieldDefs = builder.getField(FIELD_NAME2);
65         field2 = new BasicStepField(step, fieldDefs);
66         instance2 = new BasicFieldCompareConstraint(field2);
67     }
68     
69     /**
70      * Tears down after each test.
71      */

72     public void tearDown() throws Exception JavaDoc {}
73     
74     /** Test of setOperator method, of class org.mmbase.storage.search.implementation.BasicFieldCompareConstraint. */
75     public void testSetOperator() {
76         // Default is EQUAL.
77
assertTrue(instance1.getOperator() == FieldCompareConstraint.EQUAL);
78         assertTrue(instance2.getOperator() == FieldCompareConstraint.EQUAL);
79         
80         // Invalid operator value, should throw IllegalArgumentException.
81
try {
82             instance1.setOperator(-123);
83             fail("Invalid operator value, should throw IllegalArgumentException.");
84         } catch (IllegalArgumentException JavaDoc e) {}
85         try {
86             instance2.setOperator(-123);
87             fail("Invalid operator value, should throw IllegalArgumentException.");
88         } catch (IllegalArgumentException JavaDoc e) {}
89         try {
90             instance1.setOperator(0);
91             fail("Invalid operator value, should throw IllegalArgumentException.");
92         } catch (IllegalArgumentException JavaDoc e) {}
93         try {
94             instance2.setOperator(0);
95             fail("Invalid operator value, should throw IllegalArgumentException.");
96         } catch (IllegalArgumentException JavaDoc e) {}
97         try {
98             instance1.setOperator(100);
99             fail("Invalid operator value, should throw IllegalArgumentException.");
100         } catch (IllegalArgumentException JavaDoc e) {}
101         try {
102             instance2.setOperator(100);
103             fail("Invalid operator value, should throw IllegalArgumentException.");
104         } catch (IllegalArgumentException JavaDoc e) {}
105         
106         instance1.setOperator(FieldCompareConstraint.LESS);
107         assertTrue(instance1.getOperator() == FieldCompareConstraint.LESS);
108         instance2.setOperator(FieldCompareConstraint.LESS);
109         assertTrue(instance2.getOperator() == FieldCompareConstraint.LESS);
110         instance1.setOperator(FieldCompareConstraint.LESS_EQUAL);
111         assertTrue(instance1.getOperator() == FieldCompareConstraint.LESS_EQUAL);
112         instance2.setOperator(FieldCompareConstraint.LESS_EQUAL);
113         assertTrue(instance2.getOperator() == FieldCompareConstraint.LESS_EQUAL);
114         instance1.setOperator(FieldCompareConstraint.EQUAL);
115         assertTrue(instance1.getOperator() == FieldCompareConstraint.EQUAL);
116         instance2.setOperator(FieldCompareConstraint.EQUAL);
117         assertTrue(instance2.getOperator() == FieldCompareConstraint.EQUAL);
118         instance1.setOperator(FieldCompareConstraint.NOT_EQUAL);
119         assertTrue(instance1.getOperator() == FieldCompareConstraint.NOT_EQUAL);
120         instance2.setOperator(FieldCompareConstraint.NOT_EQUAL);
121         assertTrue(instance2.getOperator() == FieldCompareConstraint.NOT_EQUAL);
122         instance1.setOperator(FieldCompareConstraint.GREATER);
123         assertTrue(instance1.getOperator() == FieldCompareConstraint.GREATER);
124         instance2.setOperator(FieldCompareConstraint.GREATER);
125         assertTrue(instance2.getOperator() == FieldCompareConstraint.GREATER);
126         instance1.setOperator(FieldCompareConstraint.GREATER_EQUAL);
127         assertTrue(instance1.getOperator() == FieldCompareConstraint.GREATER_EQUAL);
128         instance2.setOperator(FieldCompareConstraint.GREATER_EQUAL);
129         assertTrue(instance2.getOperator() == FieldCompareConstraint.GREATER_EQUAL);
130         BasicFieldCompareConstraint result
131             = instance1.setOperator(FieldCompareConstraint.LIKE);
132         assertTrue(instance1.getOperator() == FieldCompareConstraint.LIKE);
133         assertTrue(result == instance1);
134         try {
135             // Like operator for integer type field, should throw IllegalArgumentException.
136
instance2.setOperator(FieldCompareConstraint.LIKE);
137             fail("Like operator for integer type field, should throw IllegalArgumentException.");
138         } catch (IllegalArgumentException JavaDoc e) {}
139     }
140     
141     /** Test of getOperator method, of class org.mmbase.storage.search.implementation.BasicFieldCompareConstraint. */
142     public void testGetOperator() {
143         // Same as:
144
testSetOperator();
145     }
146     
147     /** Test of getBasicSupportLevel method. */
148     public void testGetBasicSupportLevel() {
149         // Returns SUPPORT_OPTIMAL.
150
assertTrue(instance1.getBasicSupportLevel() == SearchQueryHandler.SUPPORT_OPTIMAL);
151     }
152     
153     /** Test of equals method, of class org.mmbase.storage.search.implementation.BasicFieldCompareConstraint. */
154     public void testEquals() {
155         // TODO: implement test
156
}
157     
158     /** Test of hashCode method, of class org.mmbase.storage.search.implementation.BasicFieldCompareConstraint. */
159     public void testHashCode() {
160         // TODO: implement test
161
}
162     
163     public static Test suite() {
164         TestSuite suite = new TestSuite(BasicFieldCompareConstraintTest.class);
165         
166         return suite;
167     }
168     
169 }
170
Popular Tags