1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.beanutils.expression;
18
19 import junit.framework.TestCase;
20 import junit.framework.TestSuite;
21
22 /***
23 * Junit Test for BasicResolver.
24 */
25 public class DefaultResolverTestCase extends TestCase {
26
27 private DefaultResolver resolver = new DefaultResolver();
28
29
30 private String[] validProperties = new String[] {null, "", "a", "bc", "def", "g.h", "ij.k", "lm.no", "pqr.stu"};
31 private String[] validNames = new String[] {null, "", "a", "bc", "def", "g", "ij", "lm", "pqr"};
32
33
34 private String[] validIndexProperties = new String[] {"a[1]", "b[12]", "cd[3]", "ef[45]", "ghi[6]", "jkl[789]", };
35 private String[] validIndexNames = new String[] {"a", "b", "cd", "ef", "ghi", "jkl"};
36 private int[] validIndexValues = new int[] {1, 12, 3, 45, 6, 789};
37
38
39 private String[] validMapProperties = new String[] {"a(b)", "c(de)", "fg(h)", "ij(kl)", "mno(pqr.s)", "tuv(wx).yz[1]"};
40 private String[] validMapNames = new String[] {"a", "c", "fg", "ij", "mno", "tuv"};
41 private String[] validMapKeys = new String[] {"b", "de", "h", "kl", "pqr.s", "wx"};
42
43 private String[] nextExpressions = new String[] {"a", "bc", "d.e", "fg.h", "ij.kl", "m(12)", "no(3.4)", "pq(r).s", "t[12]", "uv[34].wx"};
44 private String[] nextProperties = new String[] {"a", "bc", "d", "fg", "ij", "m(12)", "no(3.4)", "pq(r)", "t[12]", "uv[34]"};
45 private String[] removeProperties = new String[] {null, null, "e", "h", "kl", null, null, "s", null, "wx"};
46
47 /***
48 * Construct a DefaultResolver Test Case.
49 * @param name The name of the test
50 */
51 public DefaultResolverTestCase(String name) {
52 super(name);
53 }
54
55
56
57 /***
58 * Create Test Suite
59 * @return test suite
60 */
61 public static TestSuite suite() {
62 return new TestSuite(DefaultResolverTestCase.class);
63 }
64
65 /***
66 * Set Up
67 */
68 protected void setUp() {
69 }
70
71 /***
72 * Tear Down
73 */
74 protected void tearDown() {
75 }
76
77
78
79 /***
80 * Test getIndex() method.
81 */
82 public void testGetIndex() {
83 String label = null;
84
85
86 for (int i = 0; i < validProperties.length; i++) {
87 try {
88 label = "Simple " + label(validProperties[i], i);
89 assertEquals(label, -1, resolver.getIndex(validProperties[i]));
90 } catch (Throwable t) {
91 fail(label + " threw " + t);
92 }
93 }
94
95
96 for (int i = 0; i < validIndexProperties.length; i++) {
97 try {
98 label = "Indexed " + label(validIndexProperties[i], i);
99 assertEquals(label, validIndexValues[i], resolver.getIndex(validIndexProperties[i]));
100 } catch (Throwable t) {
101 fail(label + " threw " + t);
102 }
103 }
104
105
106 for (int i = 0; i < validMapProperties.length; i++) {
107 try {
108 label = "Mapped " + label(validMapProperties[i], i);
109 assertEquals(label, -1, resolver.getIndex(validMapProperties[i]));
110 } catch (Throwable t) {
111 fail(label + " threw " + t);
112 }
113 }
114
115
116 label = "Missing Index";
117 try {
118 int index = resolver.getIndex("foo[]");
119 fail(label + " expected IllegalArgumentException: " + index);
120 } catch (IllegalArgumentException e) {
121 assertEquals(label + " Error Message", "No Index Value", e.getMessage());
122 } catch (Throwable t) {
123 fail(label + " expected IllegalArgumentException: " + t);
124 }
125
126
127 label = "Malformed";
128 try {
129 int index = resolver.getIndex("foo[12");
130 fail(label + " expected IllegalArgumentException: " + index);
131 } catch (IllegalArgumentException e) {
132 assertEquals(label + " Error Message", "Missing End Delimiter", e.getMessage());
133 } catch (Throwable t) {
134 fail(label + " expected IllegalArgumentException: " + t);
135 }
136
137
138 label = "Malformed";
139 try {
140 int index = resolver.getIndex("foo[BAR]");
141 fail(label + " expected IllegalArgumentException: " + index);
142 } catch (IllegalArgumentException e) {
143 assertEquals(label + " Error Message", "Invalid index value 'BAR'", e.getMessage());
144 } catch (Throwable t) {
145 fail(label + " expected IllegalArgumentException: " + t);
146 }
147 }
148
149 /***
150 * Test getMapKey() method.
151 */
152 public void testGetMapKey() {
153 String label = null;
154
155
156 for (int i = 0; i < validProperties.length; i++) {
157 try {
158 label = "Simple " + label(validProperties[i], i);
159 assertEquals(label, null, resolver.getKey(validProperties[i]));
160 } catch (Throwable t) {
161 fail(label + " threw " + t);
162 }
163 }
164
165
166 for (int i = 0; i < validIndexProperties.length; i++) {
167 try {
168 label = "Indexed " + label(validIndexProperties[i], i);
169 assertEquals(label, null, resolver.getKey(validIndexProperties[i]));
170 } catch (Throwable t) {
171 fail(label + " threw " + t);
172 }
173 }
174
175
176 for (int i = 0; i < validMapProperties.length; i++) {
177 try {
178 label = "Mapped " + label(validMapProperties[i], i);
179 assertEquals(label, validMapKeys[i], resolver.getKey(validMapProperties[i]));
180 } catch (Throwable t) {
181 fail(label + " threw " + t);
182 }
183 }
184
185
186 label = "Malformed";
187 try {
188 String key = resolver.getKey("foo(bar");
189 fail(label + " expected IllegalArgumentException: " + key);
190 } catch (IllegalArgumentException e) {
191 assertEquals(label + " Error Message", "Missing End Delimiter", e.getMessage());
192 } catch (Throwable t) {
193 fail(label + " expected IllegalArgumentException: " + t);
194 }
195 }
196
197 /***
198 * Test isIndexed() method.
199 */
200 public void testIsIndexed() {
201 String label = null;
202
203
204 for (int i = 0; i < validProperties.length; i++) {
205 try {
206 label = "Simple " + label(validProperties[i], i);
207 assertFalse(label, resolver.isIndexed(validProperties[i]));
208 } catch (Throwable t) {
209 fail(label + " threw " + t);
210 }
211 }
212
213
214 for (int i = 0; i < validIndexProperties.length; i++) {
215 try {
216 label = "Indexed " + label(validIndexProperties[i], i);
217 assertTrue(label, resolver.isIndexed(validIndexProperties[i]));
218 } catch (Throwable t) {
219 fail(label + " threw " + t);
220 }
221 }
222
223
224 for (int i = 0; i < validMapProperties.length; i++) {
225 try {
226 label = "Mapped " + label(validMapProperties[i], i);
227 assertFalse(label, resolver.isIndexed(validMapProperties[i]));
228 } catch (Throwable t) {
229 fail(label + " threw " + t);
230 }
231 }
232 }
233
234 /***
235 * Test isMapped() method.
236 */
237 public void testIsMapped() {
238 String label = null;
239
240
241 for (int i = 0; i < validProperties.length; i++) {
242 try {
243 label = "Simple " + label(validProperties[i], i);
244 assertFalse(label, resolver.isMapped(validProperties[i]));
245 } catch (Throwable t) {
246 fail(label + " threw " + t);
247 }
248 }
249
250
251 for (int i = 0; i < validIndexProperties.length; i++) {
252 try {
253 label = "Indexed " + label(validIndexProperties[i], i);
254 assertFalse(label, resolver.isMapped(validIndexProperties[i]));
255 } catch (Throwable t) {
256 fail(label + " threw " + t);
257 }
258 }
259
260
261 for (int i = 0; i < validMapProperties.length; i++) {
262 try {
263 label = "Mapped " + label(validMapProperties[i], i);
264 assertTrue(label, resolver.isMapped(validMapProperties[i]));
265 } catch (Throwable t) {
266 fail(label + " threw " + t);
267 }
268 }
269 }
270
271 /***
272 * Test getName() method.
273 */
274 public void testGetName() {
275 String label = null;
276
277
278 for (int i = 0; i < validProperties.length; i++) {
279 try {
280 label = "Simple " + label(validProperties[i], i);
281 assertEquals(label, validNames[i], resolver.getProperty(validProperties[i]));
282 } catch (Throwable t) {
283 fail(label + " threw " + t);
284 }
285 }
286
287
288 for (int i = 0; i < validIndexProperties.length; i++) {
289 try {
290 label = "Indexed " + label(validIndexProperties[i], i);
291 assertEquals(label, validIndexNames[i], resolver.getProperty(validIndexProperties[i]));
292 } catch (Throwable t) {
293 fail(label + " threw " + t);
294 }
295 }
296
297
298 for (int i = 0; i < validMapProperties.length; i++) {
299 try {
300 label = "Mapped " + label(validMapProperties[i], i);
301 assertEquals(label, validMapNames[i], resolver.getProperty(validMapProperties[i]));
302 } catch (Throwable t) {
303 fail(label + " threw " + t);
304 }
305 }
306 }
307
308 /***
309 * Test next() method.
310 */
311 public void testNext() {
312 String label = null;
313 for (int i = 0; i < nextExpressions.length; i++) {
314 try {
315 label = label(nextExpressions[i], i);
316 assertEquals(label, nextProperties[i], resolver.next(nextExpressions[i]));
317 } catch (Throwable t) {
318 fail(label + " threw " + t);
319 }
320 }
321 }
322
323 /***
324 * Test remove() method.
325 */
326 public void testRemove() {
327 String label = null;
328 for (int i = 0; i < nextExpressions.length; i++) {
329 try {
330 label = label(nextExpressions[i], i);
331 assertEquals(label, removeProperties[i], resolver.remove(nextExpressions[i]));
332 } catch (Throwable t) {
333 fail(label + " threw " + t);
334 }
335 }
336 }
337
338 private String label(String expression, int i) {
339 return "Expression[" + i + "]=\"" + expression + "\"";
340 }
341 }