1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.beanutils.bugs;
18  
19  import java.util.HashMap;
20  import java.util.Map;
21  
22  import junit.framework.Test;
23  import junit.framework.TestCase;
24  import junit.framework.TestSuite;
25  
26  import org.apache.commons.beanutils.BeanUtils;
27  import org.apache.commons.beanutils.PropertyUtils;
28  import org.apache.commons.beanutils.WrapDynaBean;
29  import org.apache.commons.beanutils.bugs.other.Jira61BeanFactory;
30  import org.apache.commons.beanutils.bugs.other.Jira61BeanFactory.TestBean;
31  import org.apache.commons.logging.Log;
32  import org.apache.commons.logging.LogFactory;
33  
34  /***
35   * Test case for Jira issue# BEANUTILS-61.
36   * <p />
37   * See https://issues.apache.org/jira/browse/BEANUTILS-61
38   * <p />
39   *
40   * {@link WrapDynaBean} is a secial case for the PropertyUtils's
41   * isReadable() and isWriteable() methods - since the bean being
42   * wrapped may have read-only or write-only properties (unlike
43   * regular DynaBeans.
44   *
45   * @version $Revision: 553357 $ $Date: 2007-07-05 02:10:25 +0100 (Thu, 05 Jul 2007) $
46   */
47  public class Jira61TestCase extends TestCase {
48  
49      private Log log = LogFactory.getLog(Jira61TestCase.class);
50      private Jira61BeanFactory.TestBean testBean;
51      private WrapDynaBean wrapDynaBean;
52  
53      /***
54       * Create a test case with the specified name.
55       *
56       * @param name The name of the test
57       */
58      public Jira61TestCase(String name) {
59          super(name);
60      }
61  
62      /***
63       * Run the Test.
64       *
65       * @param args Arguments
66       */
67      public static void main(String[] args) {
68          junit.textui.TestRunner.run(suite());
69      }
70  
71      /***
72       * Create a test suite for this test.
73       *
74       * @return a test suite
75       */
76      public static Test suite() {
77          return (new TestSuite(Jira61TestCase.class));
78      }
79  
80      /***
81       * Set up.
82       *
83       * @throws java.lang.Exception
84       */
85      protected void setUp() throws Exception {
86          super.setUp();
87          testBean = Jira61BeanFactory.createBean();
88          PropertyUtils.getPropertyDescriptor(testBean, "mappedReadOnly");
89          PropertyUtils.getPropertyDescriptor(testBean, "mappedWriteOnly");
90          wrapDynaBean = new WrapDynaBean(testBean);
91      }
92  
93      /***
94       * Tear Down.
95       *
96       * @throws java.lang.Exception
97       */
98      protected void tearDown() throws Exception {
99          super.tearDown();
100     }
101 
102     /***
103      * Test {@link PropertyUtils#isReadable(Object, String)}
104      * for simple properties.
105      */
106     public void testIssue_BEANUTILS_61_PropertyUtils_isReadable() {
107         boolean result = false;
108 
109         try {
110             result = PropertyUtils.isReadable(wrapDynaBean, "simpleReadOnly");
111         } catch (Throwable t) {
112             log.error("ERROR " + t, t);
113             fail("simpleReadOnly Threw exception: " + t);
114         }
115         assertTrue("PropertyUtils.isReadable(bean, \"simpleReadOnly\") returned " + result, result);
116 
117         try {
118             result = PropertyUtils.isReadable(wrapDynaBean, "simpleWriteOnly");
119         } catch (Throwable t) {
120             log.error("ERROR " + t, t);
121             fail("simpleWriteOnly Threw exception: " + t);
122         }
123         assertFalse("PropertyUtils.isReadable(bean, \"simpleWriteOnly\") returned " + result, result);
124     }
125 
126     /***
127      * Test {@link PropertyUtils#isWriteable(Object, String)}
128      * for simple properties.
129      */
130     public void testIssue_BEANUTILS_61_PropertyUtils_isWriteable() {
131         boolean result = false;
132 
133         try {
134             result = PropertyUtils.isWriteable(wrapDynaBean, "simpleReadOnly");
135         } catch (Throwable t) {
136             log.error("ERROR " + t, t);
137             fail("simpleReadOnly Threw exception: " + t);
138         }
139         assertFalse("PropertyUtils.isWriteable(bean, \"simpleReadOnly\") returned " + result, result);
140 
141         try {
142             result = PropertyUtils.isWriteable(wrapDynaBean, "simpleWriteOnly");
143         } catch (Throwable t) {
144             log.error("ERROR " + t, t);
145             fail("simpleWriteOnly Threw exception: " + t);
146         }
147         assertTrue("PropertyUtils.isWriteable(bean, \"simpleWriteOnly\") returned " + result, result);
148     }
149 
150     /***
151      * Test {@link PropertyUtils#isReadable(Object, String)}
152      * for indexed properties.
153      */
154     public void testIssue_BEANUTILS_61_PropertyUtils_isReadable_Indexed() {
155         boolean result = false;
156 
157         try {
158             result = PropertyUtils.isReadable(wrapDynaBean, "indexedReadOnly");
159         } catch (Throwable t) {
160             log.error("ERROR " + t, t);
161             fail("indexedReadOnly Threw exception: " + t);
162         }
163         assertTrue("PropertyUtils.isReadable(bean, \"indexedReadOnly\") returned " + result, result);
164 
165         try {
166             result = PropertyUtils.isReadable(wrapDynaBean, "indexedWriteOnly");
167         } catch (Throwable t) {
168             log.error("ERROR " + t, t);
169             fail("indexedWriteOnly Threw exception: " + t);
170         }
171         assertFalse("PropertyUtils.isReadable(bean, \"indexedWriteOnly\") returned " + result, result);
172     }
173 
174     /***
175      * Test {@link PropertyUtils#isReadable(Object, String)}
176      * for mapped properties.
177      */
178     public void testIssue_BEANUTILS_61_PropertyUtils_isReadable_Mapped() {
179         boolean result = false;
180 
181         try {
182             result = PropertyUtils.isReadable(wrapDynaBean, "mappedReadOnly");
183         } catch (Throwable t) {
184             log.error("ERROR " + t, t);
185             fail("mappedReadOnly Threw exception: " + t);
186         }
187         assertTrue("PropertyUtils.isReadable(bean, \"mappedReadOnly\") returned " + result, result);
188 
189         try {
190             result = PropertyUtils.isReadable(wrapDynaBean, "mappedWriteOnly");
191         } catch (Throwable t) {
192             log.error("ERROR " + t, t);
193             fail("mappedWriteOnly Threw exception: " + t);
194         }
195         assertFalse("PropertyUtils.isReadable(bean, \"mappedWriteOnly\") returned " + result, result);
196     }
197 
198     /***
199      * Test {@link PropertyUtils#isWriteable(Object, String)}
200      * for indexed properties.
201      */
202     public void testIssue_BEANUTILS_61_PropertyUtils_isWriteable_Indexed() {
203         boolean result = false;
204 
205         try {
206             result = PropertyUtils.isWriteable(wrapDynaBean, "indexedReadOnly");
207         } catch (Throwable t) {
208             log.error("ERROR " + t, t);
209             fail("indexedReadOnly Threw exception: " + t);
210         }
211         assertFalse("PropertyUtils.isWriteable(bean, \"indexedReadOnly\") returned " + result, result);
212 
213         try {
214             result = PropertyUtils.isWriteable(wrapDynaBean, "indexedWriteOnly");
215         } catch (Throwable t) {
216             log.error("ERROR " + t, t);
217             fail("indexedWriteOnly Threw exception: " + t);
218         }
219         assertTrue("PropertyUtils.isWriteable(bean, \"indexedWriteOnly\") returned " + result, result);
220     }
221 
222     /***
223      * Test {@link PropertyUtils#isWriteable(Object, String)}
224      * for mapped properties.
225      */
226     public void testIssue_BEANUTILS_61_PropertyUtils_isWriteable_Mapped() {
227         boolean result = false;
228 
229         try {
230             result = PropertyUtils.isWriteable(wrapDynaBean, "mappedReadOnly");
231         } catch (Throwable t) {
232             log.error("ERROR " + t, t);
233             fail("mappedReadOnly Threw exception: " + t);
234         }
235         assertFalse("PropertyUtils.isWriteable(bean, \"mappedReadOnly\") returned " + result, result);
236 
237         try {
238             result = PropertyUtils.isWriteable(wrapDynaBean, "mappedWriteOnly");
239         } catch (Throwable t) {
240             log.error("ERROR " + t, t);
241             fail("mappedWriteOnly Threw exception: " + t);
242         }
243         assertTrue("PropertyUtils.isWriteable(bean, \"mappedWriteOnly\") returned " + result, result);
244     }
245 
246     /***
247      * Test {@link PropertyUtils#getProperty(Object, String)}
248      * for simple properties.
249      */
250     public void testIssue_BEANUTILS_61_PropertyUtils_getProperty() {
251         boolean threwIllegalArgumentException = false;
252         Object result = null;
253         try {
254             result = PropertyUtils.getProperty(wrapDynaBean, "simpleReadOnly");
255         } catch (Throwable t) {
256             log.error("ERROR " + t, t);
257             fail("simpleWriteOnly Threw exception: " + t);
258         }
259         assertEquals("simpleReadOnly", testBean.getSimpleReadOnly(), result);
260 
261         try {
262             result = PropertyUtils.getProperty(wrapDynaBean, "simpleWriteOnly");
263         } catch (IllegalArgumentException ex) {
264             threwIllegalArgumentException = true; // expected result
265         } catch (Throwable t) {
266             log.error("ERROR " + t, t);
267             fail("simpleWriteOnly Threw exception: " + t);
268         }
269         assertTrue("Expected IllegalArgumentException but returned '" + result + "'", threwIllegalArgumentException);
270     }
271 
272     /***
273      * Test {@link PropertyUtils#setProperty(Object, String, Object)}
274      * for simple properties.
275      */
276     public void testIssue_BEANUTILS_61_PropertyUtils_setProperty() {
277         boolean threwIllegalArgumentException = false;
278         try {
279             PropertyUtils.setProperty(wrapDynaBean, "simpleReadOnly", "READONLY-SIMPLE-BAR");
280         } catch (IllegalArgumentException ex) {
281             threwIllegalArgumentException = true; // expected result
282         } catch (Throwable t) {
283             log.error("ERROR " + t, t);
284             fail("simpleReadOnly Threw exception: " + t);
285         }
286         assertTrue("Expected IllegalArgumentException", threwIllegalArgumentException);
287 
288         try {
289             PropertyUtils.setProperty(wrapDynaBean, "simpleWriteOnly", "SIMPLE-BAR");
290         } catch (Throwable t) {
291             log.error("ERROR " + t, t);
292             fail("simpleWriteOnly Threw exception: " + t);
293         }
294         assertEquals("simpleWriteOnly", testBean.getSimpleReadOnly(), "SIMPLE-BAR");
295     }
296 
297     /***
298      * Test {@link PropertyUtils#getProperty(Object, String)}
299      * for indexed properties.
300      */
301     public void testIssue_BEANUTILS_61_PropertyUtils_getProperty_Indexed() {
302         boolean threwIllegalArgumentException = false;
303         Object result = null;
304         try {
305             result = PropertyUtils.getProperty(wrapDynaBean, "indexedReadOnly[0]");
306         } catch (Throwable t) {
307             log.error("ERROR " + t, t);
308             fail("indexedReadOnly Threw exception: " + t);
309         }
310         assertEquals("indexedReadOnly", testBean.getIndexedReadOnly(0), result);
311 
312         try {
313             result = PropertyUtils.getProperty(wrapDynaBean, "indexedWriteOnly[0]");
314         } catch (IllegalArgumentException ex) {
315             threwIllegalArgumentException = true; // expected result
316         } catch (Throwable t) {
317             log.error("ERROR " + t, t);
318             fail("indexedWriteOnly Threw exception: " + t);
319         }
320         assertTrue("Expected IllegalArgumentException but returned '" + result + "'", threwIllegalArgumentException);
321     }
322 
323     /***
324      * Test {@link PropertyUtils#setProperty(Object, String, Object)}
325      * for indexed properties.
326      */
327     public void testIssue_BEANUTILS_61_PropertyUtils_setProperty_Indexed() {
328         boolean threwIllegalArgumentException = false;
329         try {
330             PropertyUtils.setProperty(wrapDynaBean, "indexedReadOnly[0]", "READONLY-INDEXED-BAR");
331         } catch (IllegalArgumentException ex) {
332             threwIllegalArgumentException = true; // expected result
333         } catch (Throwable t) {
334             log.error("ERROR " + t, t);
335             fail("indexedReadOnly Threw exception: " + t);
336         }
337         assertTrue("Expected IllegalArgumentException", threwIllegalArgumentException);
338 
339         try {
340             PropertyUtils.setProperty(wrapDynaBean, "indexedWriteOnly[0]", "INDEXED-BAR");
341         } catch (Throwable t) {
342             log.error("ERROR " + t, t);
343             fail("indexedWriteOnly Threw exception: " + t);
344         }
345         assertEquals("indexedWriteOnly", testBean.getIndexedReadOnly(0), "INDEXED-BAR");
346     }
347 
348     /***
349      * Test {@link PropertyUtils#getProperty(Object, String)}
350      * for mapped properties.
351      */
352     public void testIssue_BEANUTILS_61_PropertyUtils_getProperty_Mapped() {
353         boolean threwIllegalArgumentException = false;
354         Object result = null;
355         try {
356             result = PropertyUtils.getProperty(wrapDynaBean, "mappedReadOnly(foo-key)");
357         } catch (Throwable t) {
358             log.error("ERROR " + t, t);
359             fail("mappedReadOnly Threw exception: " + t);
360         }
361         assertEquals("mappedReadOnly", testBean.getMappedReadOnly("foo-key"), result);
362 
363         try {
364             result = PropertyUtils.getProperty(wrapDynaBean, "mappedWriteOnly(foo-key)");
365         } catch (IllegalArgumentException ex) {
366             threwIllegalArgumentException = true; // expected result
367         } catch (Throwable t) {
368             log.error("ERROR " + t, t);
369             fail("mappedWriteOnly Threw exception: " + t);
370         }
371         assertTrue("Expected IllegalArgumentException but returned '" + result + "'", threwIllegalArgumentException);
372     }
373 
374     /***
375      * Test {@link PropertyUtils#setProperty(Object, String, Object)}
376      * for mapped properties.
377      */
378     public void testIssue_BEANUTILS_61_PropertyUtils_setProperty_Mapped() {
379         boolean threwIllegalArgumentException = false;
380         try {
381             PropertyUtils.setProperty(wrapDynaBean, "mappedReadOnly(foo-key)", "READONLY-MAPPED-BAR");
382         } catch (IllegalArgumentException ex) {
383             threwIllegalArgumentException = true; // expected result
384         } catch (Throwable t) {
385             log.error("ERROR " + t, t);
386             fail("mappedReadOnly Threw exception: " + t);
387         }
388         assertTrue("Expected IllegalArgumentException", threwIllegalArgumentException);
389 
390         try {
391             PropertyUtils.setProperty(wrapDynaBean, "mappedWriteOnly(foo-key)", "MAPPED-BAR");
392         } catch (Throwable t) {
393             log.error("ERROR " + t, t);
394             fail("mappedWriteOnly Threw exception: " + t);
395         }
396         assertEquals("mappedWriteOnly", testBean.getMappedReadOnly("foo-key"), "MAPPED-BAR");
397     }
398 
399     /***
400      * Test {@link PropertyUtils#copyProperties(Object, Object)}
401      * to a read-only WrapDynaBean property.
402      */
403     public void testIssue_BEANUTILS_61_PropertyUtils_copyProperties_to_WrapDynaBean() {
404         String value = "copied simpleReadOnly";
405         Map source = new HashMap();
406         source.put("simpleReadOnly", value);
407         try {
408             PropertyUtils.copyProperties(wrapDynaBean, source);
409         } catch (Throwable t) {
410             log.error("ERROR " + t, t);
411             fail("copyProperties Threw exception: " + t);
412         }
413         assertFalse("Target value='" + value + "'", value.equals(testBean.getSimpleReadOnly()));
414     }
415 
416     /***
417      * Test {@link PropertyUtils#copyProperties(Object, Object)}
418      * to a read-only WrapDynaBean property.
419      */
420     public void testIssue_BEANUTILS_61_PropertyUtils_copyProperties_from_WrapDynaBean() {
421         String value = "ORIG TARGET VALUE";
422         TestBean targetBean = Jira61BeanFactory.createBean();
423         targetBean.setSimpleWriteOnly(value);
424         try {
425             PropertyUtils.copyProperties(targetBean, wrapDynaBean);
426         } catch (Throwable t) {
427             log.error("ERROR " + t, t);
428             fail("copyProperties Threw exception: " + t);
429         }
430         assertTrue("Target value='" + targetBean.getSimpleReadOnly() + "'", value.equals(targetBean.getSimpleReadOnly()));
431     }
432 
433     /***
434      * Test {@link BeanUtils#copyProperties(Object, Object)}
435      * to a read-only WrapDynaBean property.
436      */
437     public void testIssue_BEANUTILS_61_BeanUtils_copyProperties_to_WrapDynaBean() {
438         String value = "copied simpleReadOnly";
439         Map source = new HashMap();
440         source.put("simpleReadOnly", value);
441         try {
442             BeanUtils.copyProperties(wrapDynaBean, source);
443         } catch (Throwable t) {
444             log.error("ERROR " + t, t);
445             fail("copyProperties Threw exception: " + t);
446         }
447         assertFalse("Target value='" + value + "'", value.equals(testBean.getSimpleReadOnly()));
448     }
449 
450     /***
451      * Test {@link BeanUtils#copyProperties(Object, Object)}
452      * to a read-only WrapDynaBean property.
453      */
454     public void testIssue_BEANUTILS_61_BeanUtils_copyProperties_from_WrapDynaBean() {
455         String value = "ORIG TARGET VALUE";
456         TestBean targetBean = Jira61BeanFactory.createBean();
457         targetBean.setSimpleWriteOnly(value);
458         try {
459             BeanUtils.copyProperties(targetBean, wrapDynaBean);
460         } catch (Throwable t) {
461             log.error("ERROR " + t, t);
462             fail("copyProperties Threw exception: " + t);
463         }
464         assertTrue("Target value='" + targetBean.getSimpleReadOnly() + "'", value.equals(targetBean.getSimpleReadOnly()));
465     }
466 }