1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.configuration;
18
19 import java.math.BigDecimal;
20 import java.util.List;
21 import java.util.Iterator;
22
23 import junit.framework.TestCase;
24
25 /***
26 * Test class for PropertyConverter.
27 *
28 * @author Emmanuel Bourg
29 * @version $Revision: 439648 $, $Date: 2006-09-02 22:42:10 +0200 (Sa, 02 Sep 2006) $
30 */
31 public class TestPropertyConverter extends TestCase
32 {
33 public void testSplit()
34 {
35 String s = "abc, xyz , 123";
36 List list = PropertyConverter.split(s, ',');
37
38 assertEquals("size", 3, list.size());
39 assertEquals("1st token for '" + s + "'", "abc", list.get(0));
40 assertEquals("2nd token for '" + s + "'", "xyz", list.get(1));
41 assertEquals("3rd token for '" + s + "'", "123", list.get(2));
42 }
43
44 public void testSplitWithEscapedSeparator()
45 {
46 String s = "abc//,xyz, 123";
47 List list = PropertyConverter.split(s, ',');
48
49 assertEquals("size", 2, list.size());
50 assertEquals("1st token for '" + s + "'", "abc,xyz", list.get(0));
51 assertEquals("2nd token for '" + s + "'", "123", list.get(1));
52 }
53
54 public void testSplitEmptyValues()
55 {
56 String s = ",,";
57 List list = PropertyConverter.split(s, ',');
58
59 assertEquals("size", 3, list.size());
60 assertEquals("1st token for '" + s + "'", "", list.get(0));
61 assertEquals("2nd token for '" + s + "'", "", list.get(1));
62 assertEquals("3rd token for '" + s + "'", "", list.get(2));
63 }
64
65 public void testSplitWithEndingSlash()
66 {
67 String s = "abc, xyz//";
68 List list = PropertyConverter.split(s, ',');
69
70 assertEquals("size", 2, list.size());
71 assertEquals("1st token for '" + s + "'", "abc", list.get(0));
72 assertEquals("2nd token for '" + s + "'", "xyz//", list.get(1));
73 }
74
75 public void testSplitNull()
76 {
77 List list = PropertyConverter.split(null, ',');
78 assertNotNull(list);
79 assertTrue(list.isEmpty());
80 }
81
82 public void testToIterator()
83 {
84 int[] array = new int[]{1, 2, 3};
85
86 Iterator it = PropertyConverter.toIterator(array, ',');
87
88 assertEquals("1st element", new Integer(1), it.next());
89 assertEquals("2nd element", new Integer(2), it.next());
90 assertEquals("3rd element", new Integer(3), it.next());
91 }
92
93 /***
94 * Tests the interpolation features.
95 */
96 public void testInterpolateString()
97 {
98 PropertiesConfiguration config = new PropertiesConfiguration();
99 config.addProperty("animal", "quick brown fox");
100 config.addProperty("target", "lazy dog");
101 assertEquals("Wrong interpolation",
102 "The quick brown fox jumps over the lazy dog.",
103 PropertyConverter.interpolate(
104 "The ${animal} jumps over the ${target}.", config));
105 }
106
107 /***
108 * Tests interpolation of an object. Here nothing should be substituted.
109 */
110 public void testInterpolateObject()
111 {
112 assertEquals("Object was not correctly interpolated", new Integer(42),
113 PropertyConverter.interpolate(new Integer(42),
114 new PropertiesConfiguration()));
115 }
116
117 /***
118 * Tests complex interpolation where the variables' values contain in turn
119 * other variables.
120 */
121 public void testInterpolateRecursive()
122 {
123 PropertiesConfiguration config = new PropertiesConfiguration();
124 config.addProperty("animal", "${animal_attr} fox");
125 config.addProperty("target", "${target_attr} dog");
126 config.addProperty("animal_attr", "quick brown");
127 config.addProperty("target_attr", "lazy");
128 assertEquals("Wrong complex interpolation",
129 "The quick brown fox jumps over the lazy dog.",
130 PropertyConverter.interpolate(
131 "The ${animal} jumps over the ${target}.", config));
132 }
133
134 /***
135 * Tests an interpolation that leads to a cycle. This should throw an
136 * exception.
137 */
138 public void testCyclicInterpolation()
139 {
140 PropertiesConfiguration config = new PropertiesConfiguration();
141 config.addProperty("animal", "${animal_attr} ${species}");
142 config.addProperty("animal_attr", "quick brown");
143 config.addProperty("species", "${animal}");
144 try
145 {
146 PropertyConverter.interpolate("This is a ${animal}", config);
147 fail("Cyclic interpolation was not detected!");
148 }
149 catch (IllegalStateException iex)
150 {
151
152 }
153 }
154
155 /***
156 * Tests interpolation if a variable is unknown. Then the variable won't be
157 * substituted.
158 */
159 public void testInterpolationUnknownVariable()
160 {
161 PropertiesConfiguration config = new PropertiesConfiguration();
162 config.addProperty("animal", "quick brown fox");
163 assertEquals("Wrong interpolation",
164 "The quick brown fox jumps over ${target}.", PropertyConverter
165 .interpolate("The ${animal} jumps over ${target}.",
166 config));
167 }
168
169 /***
170 * Tests conversion to numbers when the passed in objects are already
171 * numbers.
172 */
173 public void testToNumberDirect()
174 {
175 Integer i = new Integer(42);
176 assertSame("Wrong integer", i, PropertyConverter.toNumber(i,
177 Integer.class));
178 BigDecimal d = new BigDecimal("3.1415");
179 assertSame("Wrong BigDecimal", d, PropertyConverter.toNumber(d,
180 Integer.class));
181 }
182
183 /***
184 * Tests conversion to numbers when the passed in objects have a compatible
185 * string representation.
186 */
187 public void testToNumberFromString()
188 {
189 assertEquals("Incorrect Integer value", new Integer(42),
190 PropertyConverter.toNumber("42", Integer.class));
191 assertEquals("Incorrect Short value", new Short((short) 10),
192 PropertyConverter.toNumber(new StringBuffer("10"), Short.class));
193 }
194
195 /***
196 * Tests conversion to numbers when the passed in objects are strings with
197 * prefixes for special radices.
198 */
199 public void testToNumberFromHexString()
200 {
201 Number n = PropertyConverter.toNumber("0x10", Integer.class);
202 assertEquals("Incorrect Integer value", 16, n.intValue());
203 }
204
205 /***
206 * Tests conversion to numbers when an invalid Hex value is passed in. This
207 * should cause an exception.
208 */
209 public void testToNumberFromInvalidHexString()
210 {
211 try
212 {
213 PropertyConverter.toNumber("0xNotAHexValue", Integer.class);
214 fail("Could convert invalid hex value!");
215 }
216 catch (ConversionException cex)
217 {
218
219 }
220 }
221
222 /***
223 * Tests conversion to numbers when the passed in objects have no numeric
224 * String representation. This should cause an exception.
225 */
226 public void testToNumberFromInvalidString()
227 {
228 try
229 {
230 PropertyConverter.toNumber("Not a number", Byte.class);
231 fail("Could convert invalid String!");
232 }
233 catch (ConversionException cex)
234 {
235
236 }
237 }
238
239 /***
240 * Tests conversion to numbers when the passed in target class is invalid.
241 * This should cause an exception.
242 */
243 public void testToNumberWithInvalidClass()
244 {
245 try
246 {
247 PropertyConverter.toNumber("42", Object.class);
248 fail("Could convert to invalid target class!");
249 }
250 catch (ConversionException cex)
251 {
252
253 }
254 }
255 }