Category

Development Platform
Home > SourceCode/Document > Java Develop > View Code
CustomEditorTestSuite.java
Package: spring-framework-1.1.1-with-dependencies.zip　[view]
Upload User: jiancairen
Upload Date: 2007-08-27
Package Size: 26458k
Code Size: 17k
Category:

Java Develop

Development Platform:

Java

CustomEditorTestSuite.java：Code Content
  1. /*
  2.  * Copyright 2002-2004 the original author or authors.
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */ 
  17. package org.springframework.beans;
  19. import java.beans.PropertyEditorSupport;
  20. import java.math.BigDecimal;
  21. import java.math.BigInteger;
  22. import java.text.NumberFormat;
  23. import java.util.Locale;
  24. import java.util.StringTokenizer;
  26. import junit.framework.TestCase;
  28. import org.springframework.beans.propertyeditors.CustomBooleanEditor;
  29. import org.springframework.beans.propertyeditors.CustomDateEditor;
  30. import org.springframework.beans.propertyeditors.CustomNumberEditor;
  31. import org.springframework.beans.propertyeditors.StringTrimmerEditor;
  33. /**
  34.  * @author Juergen Hoeller
  35.  * @since 10.06.2003
  36.  */
  37. public class CustomEditorTestSuite extends TestCase {
  39. public void testComplexObject() {
  40. TestBean t = new TestBean();
  41. String newName = "Rod";
  42. String tbString = "Kerry_34";
  43. try {
  44. BeanWrapper bw = new BeanWrapperImpl(t);
  45. bw.registerCustomEditor(ITestBean.class, null, new TestBeanEditor());
  46. MutablePropertyValues pvs = new MutablePropertyValues();
  47. pvs.addPropertyValue(new PropertyValue("age", new Integer(55)));
  48. pvs.addPropertyValue(new PropertyValue("name", newName));
  49. pvs.addPropertyValue(new PropertyValue("touchy", "valid"));
  50. pvs.addPropertyValue(new PropertyValue("spouse", tbString));
  51. bw.setPropertyValues(pvs);
  52. assertTrue("spouse is non-null", t.getSpouse() != null);
  53. assertTrue("spouse name is Kerry and age is 34", t.getSpouse().getName().equals("Kerry") && t.getSpouse().getAge() == 34);
  54. //assertTrue("Event source is correct", l.getEventCount() == 3);
  55. }
  56. catch (BeansException ex) {
  57. fail("Shouldn't throw exception when everything is valid: " + ex.getMessage());
  58. }
  59. }
  61. public void testCustomEditorForSingleProperty() {
  62. TestBean tb = new TestBean();
  63. BeanWrapper bw = new BeanWrapperImpl(tb);
  64. bw.registerCustomEditor(String.class, "name", new PropertyEditorSupport() {
  65. public void setAsText(String text) throws IllegalArgumentException {
  66. setValue("prefix" + text);
  67. }
  68. });
  69. try {
  70. bw.setPropertyValue("name", "value");
  71. bw.setPropertyValue("touchy", "value");
  72. }
  73. catch (BeansException ex) {
  74. fail("Should not throw BeansException: " + ex.getMessage());
  75. }
  76. assertEquals("prefixvalue", bw.getPropertyValue("name"));
  77. assertEquals("prefixvalue", tb.getName());
  78. assertEquals("value", bw.getPropertyValue("touchy"));
  79. assertEquals("value", tb.getTouchy());
  80. }
  82. public void testCustomEditorForAllStringProperties() {
  83. TestBean tb = new TestBean();
  84. BeanWrapper bw = new BeanWrapperImpl(tb);
  85. bw.registerCustomEditor(String.class, null, new PropertyEditorSupport() {
  86. public void setAsText(String text) throws IllegalArgumentException {
  87. setValue("prefix" + text);
  88. }
  89. });
  90. try {
  91. bw.setPropertyValue("name", "value");
  92. bw.setPropertyValue("touchy", "value");
  93. }
  94. catch (BeansException ex) {
  95. fail("Should not throw BeansException: " + ex.getMessage());
  96. }
  97. assertEquals("prefixvalue", bw.getPropertyValue("name"));
  98. assertEquals("prefixvalue", tb.getName());
  99. assertEquals("prefixvalue", bw.getPropertyValue("touchy"));
  100. assertEquals("prefixvalue", tb.getTouchy());
  101. }
  103. public void testCustomEditorForSingleNestedProperty() {
  104. TestBean tb = new TestBean();
  105. tb.setSpouse(new TestBean());
  106. BeanWrapper bw = new BeanWrapperImpl(tb);
  107. bw.registerCustomEditor(String.class, "spouse.name", new PropertyEditorSupport() {
  108. public void setAsText(String text) throws IllegalArgumentException {
  109. setValue("prefix" + text);
  110. }
  111. });
  112. try {
  113. bw.setPropertyValue("spouse.name", "value");
  114. bw.setPropertyValue("touchy", "value");
  115. }
  116. catch (BeansException ex) {
  117. fail("Should not throw BeansException: " + ex.getMessage());
  118. }
  119. assertEquals("prefixvalue", bw.getPropertyValue("spouse.name"));
  120. assertEquals("prefixvalue", tb.getSpouse().getName());
  121. assertEquals("value", bw.getPropertyValue("touchy"));
  122. assertEquals("value", tb.getTouchy());
  123. }
  125. public void testCustomEditorForAllNestedStringProperties() {
  126. TestBean tb = new TestBean();
  127. tb.setSpouse(new TestBean());
  128. BeanWrapper bw = new BeanWrapperImpl(tb);
  129. bw.registerCustomEditor(String.class, null, new PropertyEditorSupport() {
  130. public void setAsText(String text) throws IllegalArgumentException {
  131. setValue("prefix" + text);
  132. }
  133. });
  134. try {
  135. bw.setPropertyValue("spouse.name", "value");
  136. bw.setPropertyValue("touchy", "value");
  137. }
  138. catch (BeansException ex) {
  139. fail("Should not throw BeansException: " + ex.getMessage());
  140. }
  141. assertEquals("prefixvalue", bw.getPropertyValue("spouse.name"));
  142. assertEquals("prefixvalue", tb.getSpouse().getName());
  143. assertEquals("prefixvalue", bw.getPropertyValue("touchy"));
  144. assertEquals("prefixvalue", tb.getTouchy());
  145. }
  147. public void testBooleanPrimitiveEditor() {
  148. BooleanTestBean tb = new BooleanTestBean();
  149. BeanWrapper bw = new BeanWrapperImpl(tb);
  151. try {
  152. bw.setPropertyValue("bool1", "true");
  153. }
  154. catch (BeansException ex) {
  155. fail("Should not throw BeansException: " + ex.getMessage());
  156. }
  157. assertTrue("Correct bool1 value", Boolean.TRUE.equals(bw.getPropertyValue("bool1")));
  158. assertTrue("Correct bool1 value", tb.isBool1());
  160. try {
  161. bw.setPropertyValue("bool1", "false");
  162. }
  163. catch (BeansException ex) {
  164. fail("Should not throw BeansException: " + ex.getMessage());
  165. }
  166. assertTrue("Correct bool1 value", Boolean.FALSE.equals(bw.getPropertyValue("bool1")));
  167. assertTrue("Correct bool1 value", !tb.isBool1());
  169. try {
  170. bw.setPropertyValue("bool1", "argh");
  171. }
  172. catch (BeansException ex) {
  173. // expected
  174. return;
  175. }
  176. fail("Should have thrown BeansException");
  177. }
  179. public void testBooleanObjectEditorWithAllowEmpty() {
  180. BooleanTestBean tb = new BooleanTestBean();
  181. BeanWrapper bw = new BeanWrapperImpl(tb);
  182. bw.registerCustomEditor(Boolean.class, null, new CustomBooleanEditor(true));
  184. try {
  185. bw.setPropertyValue("bool2", "true");
  186. }
  187. catch (BeansException ex) {
  188. fail("Should not throw BeansException: " + ex.getMessage());
  189. }
  190. assertTrue("Correct bool2 value", Boolean.TRUE.equals(bw.getPropertyValue("bool2")));
  191. assertTrue("Correct bool2 value", tb.getBool2().booleanValue());
  193. try {
  194. bw.setPropertyValue("bool2", "false");
  195. }
  196. catch (BeansException ex) {
  197. fail("Should not throw BeansException: " + ex.getMessage());
  198. }
  199. assertTrue("Correct bool2 value", Boolean.FALSE.equals(bw.getPropertyValue("bool2")));
  200. assertTrue("Correct bool2 value", !tb.getBool2().booleanValue());
  202. try {
  203. bw.setPropertyValue("bool2", "");
  204. }
  205. catch (BeansException ex) {
  206. fail("Should not throw BeansException: " + ex.getMessage());
  207. }
  208. assertTrue("Correct bool2 value", bw.getPropertyValue("bool2") == null);
  209. assertTrue("Correct bool2 value", tb.getBool2() == null);
  210. }
  212. public void testBooleanObjectEditorWithoutAllowEmpty() {
  213. BooleanTestBean tb = new BooleanTestBean();
  214. BeanWrapper bw = new BeanWrapperImpl(tb);
  215. bw.registerCustomEditor(Boolean.class, null, new CustomBooleanEditor(false));
  217. try {
  218. bw.setPropertyValue("bool2", "true");
  219. }
  220. catch (BeansException ex) {
  221. fail("Should not throw BeansException: " + ex.getMessage());
  222. }
  223. assertTrue("Correct bool2 value", Boolean.TRUE.equals(bw.getPropertyValue("bool2")));
  224. assertTrue("Correct bool2 value", tb.getBool2().booleanValue());
  226. try {
  227. bw.setPropertyValue("bool2", "false");
  228. }
  229. catch (BeansException ex) {
  230. fail("Should not throw BeansException: " + ex.getMessage());
  231. }
  232. assertTrue("Correct bool2 value", Boolean.FALSE.equals(bw.getPropertyValue("bool2")));
  233. assertTrue("Correct bool2 value", !tb.getBool2().booleanValue());
  235. try {
  236. bw.setPropertyValue("bool2", "");
  237. }
  238. catch (BeansException ex) {
  239. // expected
  240. assertTrue("Correct bool2 value", bw.getPropertyValue("bool2") != null);
  241. assertTrue("Correct bool2 value", tb.getBool2() != null);
  242. return;
  243. }
  244. fail("Should have throw BeansException");
  245. }
  247. public void testNumberEditorWithoutAllowEmpty() {
  248. NumberFormat nf = NumberFormat.getNumberInstance(Locale.GERMAN);
  249. NumberTestBean tb = new NumberTestBean();
  250. BeanWrapper bw = new BeanWrapperImpl(tb);
  251. bw.registerCustomEditor(short.class, null, new CustomNumberEditor(Short.class, nf, false));
  252. bw.registerCustomEditor(Short.class, null, new CustomNumberEditor(Short.class, nf, false));
  253. bw.registerCustomEditor(int.class, null, new CustomNumberEditor(Short.class, nf, false));
  254. bw.registerCustomEditor(Integer.class, null, new CustomNumberEditor(Integer.class, nf, false));
  255. bw.registerCustomEditor(long.class, null, new CustomNumberEditor(Long.class, nf, false));
  256. bw.registerCustomEditor(Long.class, null, new CustomNumberEditor(Long.class, nf, false));
  257. bw.registerCustomEditor(BigInteger.class, null, new CustomNumberEditor(BigInteger.class, nf, false));
  258. bw.registerCustomEditor(float.class, null, new CustomNumberEditor(Float.class, nf, false));
  259. bw.registerCustomEditor(Float.class, null, new CustomNumberEditor(Float.class, nf, false));
  260. bw.registerCustomEditor(double.class, null, new CustomNumberEditor(Double.class, nf, false));
  261. bw.registerCustomEditor(Double.class, null, new CustomNumberEditor(Double.class, nf, false));
  262. bw.registerCustomEditor(BigDecimal.class, null, new CustomNumberEditor(BigDecimal.class, nf, false));
  264. try {
  265. bw.setPropertyValue("short1", "1");
  266. bw.setPropertyValue("short2", "2");
  267. bw.setPropertyValue("int1", "7");
  268. bw.setPropertyValue("int2", "8");
  269. bw.setPropertyValue("long1", "5");
  270. bw.setPropertyValue("long2", "6");
  271. bw.setPropertyValue("bigInteger", "3");
  272. bw.setPropertyValue("float1", "7,1");
  273. bw.setPropertyValue("float2", "8,1");
  274. bw.setPropertyValue("double1", "5,1");
  275. bw.setPropertyValue("double2", "6,1");
  276. bw.setPropertyValue("bigDecimal", "4");
  277. }
  278. catch (BeansException ex) {
  279. fail("Should not throw BeansException: " + ex.getMessage());
  280. }
  282. assertTrue("Correct short1 value", new Short("1").equals(bw.getPropertyValue("short1")));
  283. assertTrue("Correct short1 value", tb.getShort1() == 1);
  284. assertTrue("Correct short2 value", new Short("2").equals(bw.getPropertyValue("short2")));
  285. assertTrue("Correct short2 value", new Short("2").equals(tb.getShort2()));
  286. assertTrue("Correct int1 value", new Integer("7").equals(bw.getPropertyValue("int1")));
  287. assertTrue("Correct int1 value", tb.getInt1() == 7);
  288. assertTrue("Correct int2 value", new Integer("8").equals(bw.getPropertyValue("int2")));
  289. assertTrue("Correct int2 value", new Integer("8").equals(tb.getInt2()));
  290. assertTrue("Correct long1 value", new Long("5").equals(bw.getPropertyValue("long1")));
  291. assertTrue("Correct long1 value", tb.getLong1() == 5);
  292. assertTrue("Correct long2 value", new Long("6").equals(bw.getPropertyValue("long2")));
  293. assertTrue("Correct long2 value", new Long("6").equals(tb.getLong2()));
  294. assertTrue("Correct bigInteger value", new BigInteger("3").equals(bw.getPropertyValue("bigInteger")));
  295. assertTrue("Correct bigInteger value", new BigInteger("3").equals(tb.getBigInteger()));
  296. assertTrue("Correct float1 value", new Float("7.1").equals(bw.getPropertyValue("float1")));
  297. assertTrue("Correct float1 value", new Float("7.1").equals(new Float(tb.getFloat1())));
  298. assertTrue("Correct float2 value", new Float("8.1").equals(bw.getPropertyValue("float2")));
  299. assertTrue("Correct float2 value", new Float("8.1").equals(tb.getFloat2()));
  300. assertTrue("Correct double1 value", new Double("5.1").equals(bw.getPropertyValue("double1")));
  301. assertTrue("Correct double1 value", tb.getDouble1() == 5.1);
  302. assertTrue("Correct double2 value", new Double("6.1").equals(bw.getPropertyValue("double2")));
  303. assertTrue("Correct double2 value", new Double("6.1").equals(tb.getDouble2()));
  304. assertTrue("Correct bigDecimal value", new BigDecimal("4.0").equals(bw.getPropertyValue("bigDecimal")));
  305. assertTrue("Correct bigDecimal value", new BigDecimal("4.0").equals(tb.getBigDecimal()));
  306. }
  308. public void testNumberEditorsWithAllowEmpty() {
  309. NumberFormat nf = NumberFormat.getNumberInstance(Locale.GERMAN);
  310. NumberTestBean tb = new NumberTestBean();
  311. BeanWrapper bw = new BeanWrapperImpl(tb);
  312. bw.registerCustomEditor(long.class, null, new CustomNumberEditor(Long.class, nf, true));
  313. bw.registerCustomEditor(Long.class, null, new CustomNumberEditor(Long.class, nf, true));
  315. try {
  316. bw.setPropertyValue("long1", "5");
  317. bw.setPropertyValue("long2", "6");
  318. }
  319. catch (BeansException ex) {
  320. fail("Should not throw BeansException: " + ex.getMessage());
  321. }
  322. assertTrue("Correct long1 value", new Long("5").equals(bw.getPropertyValue("long1")));
  323. assertTrue("Correct long1 value", tb.getLong1() == 5);
  324. assertTrue("Correct long2 value", new Long("6").equals(bw.getPropertyValue("long2")));
  325. assertTrue("Correct long2 value", new Long("6").equals(tb.getLong2()));
  327. try {
  328. bw.setPropertyValue("long2", "");
  329. }
  330. catch (BeansException ex) {
  331. fail("Should not throw BeansException: " + ex.getMessage());
  332. }
  333. assertTrue("Correct long2 value", bw.getPropertyValue("long2") == null);
  334. assertTrue("Correct long2 value", tb.getLong2() == null);
  336. try {
  337. bw.setPropertyValue("long1", "");
  338. }
  339. catch (BeansException ex) {
  340. // expected
  341. assertTrue("Correct long1 value", new Long("5").equals(bw.getPropertyValue("long1")));
  342. assertTrue("Correct long1 value", tb.getLong1() == 5);
  343. return;
  344. }
  345. fail("Should have thrown BeansException");
  346. }
  348. public void testCustomBooleanEditor() {
  349. CustomBooleanEditor editor = new CustomBooleanEditor(false);
  350. editor.setAsText("true");
  351. assertEquals(Boolean.TRUE, editor.getValue());
  352. assertEquals("true", editor.getAsText());
  353. editor.setAsText("false");
  354. assertEquals(Boolean.FALSE, editor.getValue());
  355. assertEquals("false", editor.getAsText());
  356. editor.setValue(null);
  357. assertEquals(null, editor.getValue());
  358. assertEquals("", editor.getAsText());
  359. }
  361. public void testCustomBooleanEditorWithEmptyAsNull() {
  362. CustomBooleanEditor editor = new CustomBooleanEditor(true);
  363. editor.setAsText("true");
  364. assertEquals(Boolean.TRUE, editor.getValue());
  365. assertEquals("true", editor.getAsText());
  366. editor.setAsText("false");
  367. assertEquals(Boolean.FALSE, editor.getValue());
  368. assertEquals("false", editor.getAsText());
  369. editor.setValue(null);
  370. assertEquals(null, editor.getValue());
  371. assertEquals("", editor.getAsText());
  372. }
  374. public void testCustomDateEditor() {
  375. CustomDateEditor editor = new CustomDateEditor(null, false);
  376. editor.setValue(null);
  377. assertEquals(null, editor.getValue());
  378. assertEquals("", editor.getAsText());
  379. }
  381. public void testCustomDateEditorWithEmptyAsNull() {
  382. CustomDateEditor editor = new CustomDateEditor(null, true);
  383. editor.setValue(null);
  384. assertEquals(null, editor.getValue());
  385. assertEquals("", editor.getAsText());
  386. }
  388. public void testCustomNumberEditor() {
  389. CustomNumberEditor editor = new CustomNumberEditor(Integer.class, false);
  390. editor.setAsText("5");
  391. assertEquals(new Integer(5), editor.getValue());
  392. assertEquals("5", editor.getAsText());
  393. editor.setValue(null);
  394. assertEquals(null, editor.getValue());
  395. assertEquals("", editor.getAsText());
  396. }
  398. public void testCustomNumberEditorWithEmptyAsNull() {
  399. CustomNumberEditor editor = new CustomNumberEditor(Integer.class, true);
  400. editor.setAsText("5");
  401. assertEquals(new Integer(5), editor.getValue());
  402. assertEquals("5", editor.getAsText());
  403. editor.setAsText("");
  404. assertEquals(null, editor.getValue());
  405. assertEquals("", editor.getAsText());
  406. editor.setValue(null);
  407. assertEquals(null, editor.getValue());
  408. assertEquals("", editor.getAsText());
  409. }
  411. public void testStringTrimmerEditor() {
  412. StringTrimmerEditor editor = new StringTrimmerEditor(false);
  413. editor.setAsText("test");
  414. assertEquals("test", editor.getValue());
  415. assertEquals("test", editor.getAsText());
  416. editor.setAsText(" test ");
  417. assertEquals("test", editor.getValue());
  418. assertEquals("test", editor.getAsText());
  419. editor.setAsText("");
  420. assertEquals("", editor.getValue());
  421. assertEquals("", editor.getAsText());
  422. editor.setValue(null);
  423. assertEquals("", editor.getAsText());
  424. }
  426. public void testStringTrimmerEditorWithEmptyAsNull() {
  427. StringTrimmerEditor editor = new StringTrimmerEditor(true);
  428. editor.setAsText("test");
  429. assertEquals("test", editor.getValue());
  430. assertEquals("test", editor.getAsText());
  431. editor.setAsText(" test ");
  432. assertEquals("test", editor.getValue());
  433. assertEquals("test", editor.getAsText());
  434. editor.setAsText("");
  435. assertEquals(null, editor.getValue());
  436. assertEquals("", editor.getAsText());
  437. editor.setValue(null);
  438. assertEquals("", editor.getAsText());
  439. }
  442. private static class TestBeanEditor extends PropertyEditorSupport {
  444. public void setAsText(String text) {
  445. TestBean tb = new TestBean();
  446. StringTokenizer st = new StringTokenizer(text, "_");
  447. tb.setName(st.nextToken());
  448. tb.setAge(Integer.parseInt(st.nextToken()));
  449. setValue(tb);
  450. }
  451. }
  453. }