1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.ini4j;
17
18 import org.ini4j.sample.Dwarf;
19 import org.ini4j.sample.DwarfBean;
20 import org.ini4j.sample.Dwarfs;
21
22 import org.ini4j.test.DwarfsData;
23 import org.ini4j.test.DwarfsData.DwarfData;
24 import org.ini4j.test.Helper;
25
26 import static org.junit.Assert.assertEquals;
27 import static org.junit.Assert.assertNotNull;
28 import static org.junit.Assert.assertNull;
29 import static org.junit.Assert.assertTrue;
30
31 import org.junit.Test;
32
33 import java.net.URI;
34
35 public class BasicProfileTest extends Ini4jCase
36 {
37 private static final String SECTION = "section";
38 private static final String NUMBER = "number";
39 private static final String SINGLE = "single";
40 private static final String SOLO = "solo";
41 private static final String LOCATION = "location";
42 private static final String LOCATION_1 = "http://www.ini4j.org";
43 private static final String LOCATION_2 = "http://ini4j.org";
44
45
46
47
48 @Test public void test_bug_2817403() throws Exception
49 {
50 BasicProfile prof = new BasicProfile();
51 Profile.Section sec = prof.add("section");
52
53 sec.add("player.name", "Joe");
54 sec.add("player.greeting", "Hi ${player.name}!");
55 sec.add("player.domain", "foo.bar");
56 sec.add("player.email", "${player.name}@${player.domain}");
57
58
59 assertEquals("Joe", sec.fetch("player.name"));
60 assertEquals("Hi Joe!", sec.fetch("player.greeting"));
61 assertEquals("foo.bar", sec.fetch("player.domain"));
62 assertEquals("Joe@foo.bar", sec.fetch("player.email"));
63
64
65 sec = prof.add("other");
66 sec.add("option", "${section/player.name}");
67 assertEquals("Joe", sec.fetch("option"));
68 sec.put("option", "${section/player.email}");
69 assertEquals("Joe@foo.bar", sec.fetch("option"));
70 sec.put("option2", "${option} ${section/player.name} ${section/player.domain}");
71 assertEquals("Joe@foo.bar Joe foo.bar", sec.fetch("option2"));
72 }
73
74 @Test public void testAddPut()
75 {
76 Profile prof = new BasicProfile();
77
78 prof.add(SECTION, Dwarf.PROP_AGE, DwarfsData.sneezy.age);
79 prof.put(SECTION, Dwarf.PROP_HEIGHT, DwarfsData.sneezy.height);
80 prof.add(SECTION, Dwarf.PROP_HOME_DIR, DwarfsData.sneezy.homeDir);
81 prof.add(SECTION, Dwarf.PROP_WEIGHT, DwarfsData.sneezy.weight);
82 prof.put(SECTION, Dwarf.PROP_HOME_PAGE, null);
83 prof.put(SECTION, Dwarf.PROP_HOME_PAGE, DwarfsData.sneezy.homePage);
84 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[0]);
85 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[1]);
86 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[2]);
87 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[3]);
88 Helper.assertEquals(DwarfsData.sneezy, prof.get(SECTION).as(Dwarf.class));
89 assertNotNull(prof.remove(SECTION, Dwarf.PROP_FORTUNE_NUMBER));
90 assertEquals(0, prof.get(SECTION).length(Dwarf.PROP_FORTUNE_NUMBER));
91 assertNotNull(prof.remove(SECTION));
92 assertNull(prof.remove(SECTION, Dwarf.PROP_FORTUNE_NUMBER));
93 }
94
95 @Test public void testFirstUpper()
96 {
97 BasicProfile prof = new BasicProfile(true, true);
98 DwarfsRW dwarfs = prof.as(DwarfsRW.class);
99
100 dwarfs.setBashful(DwarfsData.bashful);
101 assertTrue(prof.containsKey("Bashful"));
102 assertNotNull(dwarfs.getBashful());
103 }
104
105 @Test public void testFromToAs() throws Exception
106 {
107 BasicProfile prof = new BasicProfile();
108
109 Helper.addDwarfs(prof);
110 fromToAs(prof, DwarfsData.bashful);
111 fromToAs(prof, DwarfsData.doc);
112 fromToAs(prof, DwarfsData.dopey);
113 fromToAs(prof, DwarfsData.grumpy);
114 fromToAs(prof, DwarfsData.happy);
115 fromToAs(prof, DwarfsData.sleepy);
116 fromToAs(prof, DwarfsData.sneezy);
117
118
119 DwarfsRW dwarfs = prof.as(DwarfsRW.class);
120
121 Helper.assertEquals(DwarfsData.bashful, dwarfs.getBashful());
122 Helper.assertEquals(DwarfsData.doc, dwarfs.getDoc());
123 Helper.assertEquals(DwarfsData.dopey, dwarfs.getDopey());
124 Helper.assertEquals(DwarfsData.grumpy, dwarfs.getGrumpy());
125 Helper.assertEquals(DwarfsData.happy, dwarfs.getHappy());
126 Helper.assertEquals(DwarfsData.sleepy, dwarfs.getSleepy());
127 Helper.assertEquals(DwarfsData.sneezy, dwarfs.getSneezy());
128
129
130 prof.remove(Dwarfs.PROP_BASHFUL);
131 assertNull(prof.get(Dwarfs.PROP_BASHFUL));
132 assertEquals(0, prof.length(Dwarfs.PROP_BASHFUL));
133 assertNull(dwarfs.getBashful());
134 dwarfs.setBashful(DwarfsData.dopey);
135 Helper.assertEquals(DwarfsData.dopey, dwarfs.getBashful());
136 }
137
138 @Test public void testIniGetFetch()
139 {
140 Profile prof = new BasicProfile();
141 Profile.Section sec = Helper.addDwarf(prof, DwarfsData.dopey);
142
143 Helper.addDwarf(prof, DwarfsData.bashful);
144 Helper.addDwarf(prof, DwarfsData.doc);
145 assertEquals(sec.get(Dwarf.PROP_AGE), prof.get(Dwarfs.PROP_DOPEY, Dwarf.PROP_AGE));
146 assertEquals(DwarfsData.dopey.age, (int) prof.get(Dwarfs.PROP_DOPEY, Dwarf.PROP_AGE, int.class));
147 assertEquals(sec.get(Dwarf.PROP_WEIGHT), prof.get(Dwarfs.PROP_DOPEY, Dwarf.PROP_WEIGHT));
148 assertEquals(DwarfsData.dopey.weight, prof.fetch(Dwarfs.PROP_DOPEY, Dwarf.PROP_WEIGHT, double.class), Helper.DELTA);
149 assertEquals(sec.fetch(Dwarf.PROP_HEIGHT), prof.fetch(Dwarfs.PROP_DOPEY, Dwarf.PROP_HEIGHT));
150 assertEquals(DwarfsData.dopey.weight, prof.fetch(Dwarfs.PROP_DOPEY, Dwarf.PROP_WEIGHT, double.class), Helper.DELTA);
151 assertEquals(sec.fetch(Dwarf.PROP_HOME_PAGE), prof.fetch(Dwarfs.PROP_DOPEY, Dwarf.PROP_HOME_PAGE));
152 assertEquals(DwarfsData.dopey.homePage, prof.fetch(Dwarfs.PROP_DOPEY, Dwarf.PROP_HOME_PAGE, URI.class));
153
154
155 assertNull(prof.get(SECTION, Dwarf.PROP_AGE));
156 assertEquals(0, (int) prof.get(SECTION, Dwarf.PROP_AGE, int.class));
157 assertNull(prof.get(SECTION, Dwarf.PROP_WEIGHT));
158 assertEquals(0.0, prof.fetch(SECTION, Dwarf.PROP_WEIGHT, double.class), Helper.DELTA);
159 assertNull(prof.fetch(SECTION, Dwarf.PROP_HEIGHT));
160 assertEquals(0.0, prof.fetch(SECTION, Dwarf.PROP_WEIGHT, double.class), Helper.DELTA);
161 assertNull(prof.fetch(SECTION, Dwarf.PROP_HOME_PAGE));
162 assertNull(prof.fetch(SECTION, Dwarf.PROP_HOME_PAGE, URI.class));
163 }
164
165 @Test public void testOptionArray() throws Exception
166 {
167 BasicProfile prof = new BasicProfile();
168 Profile.Section sec = prof.add(SECTION);
169
170 sec.add(NUMBER, 1);
171 sec.add(LOCATION, LOCATION_1);
172 sec.add(NUMBER, 2);
173 sec.add(LOCATION, LOCATION_2);
174 Section s = prof.get(SECTION).as(Section.class);
175
176 assertNotNull(s);
177 assertEquals(2, s.getNumber().length);
178 assertEquals(1, s.getNumber()[0]);
179 assertEquals(2, s.getNumber()[1]);
180 assertEquals(2, s.getLocation().length);
181 assertEquals(new URI(LOCATION_1), s.getLocation()[0]);
182 assertNull(s.getMissing());
183 int[] numbers = new int[] { 1, 2, 3, 4, 5 };
184
185 s.setNumber(numbers);
186 assertEquals(5, sec.length(NUMBER));
187 }
188
189 @Test public void testResolve() throws Exception
190 {
191 BasicProfile prof = new BasicProfile();
192
193 Helper.addDwarf(prof, DwarfsData.happy);
194 Profile.Section doc = Helper.addDwarf(prof, DwarfsData.doc);
195 StringBuilder buffer;
196 String input;
197
198
199 input = "${happy/weight}";
200 buffer = new StringBuilder(input);
201
202 prof.resolve(buffer, doc);
203 assertEquals(String.valueOf(DwarfsData.happy.weight), buffer.toString());
204
205
206 input = "${height}";
207 buffer = new StringBuilder(input);
208
209 prof.resolve(buffer, doc);
210 assertEquals(String.valueOf(DwarfsData.doc.height), buffer.toString());
211
212
213 input = "${@prop/user.home}";
214 buffer = new StringBuilder(input);
215
216 prof.resolve(buffer, doc);
217 assertEquals(System.getProperty("user.home"), buffer.toString());
218
219
220 input = "${@env/PATH}";
221 buffer = new StringBuilder(input);
222 try
223 {
224 prof.resolve(buffer, doc);
225 assertEquals(System.getenv("PATH"), buffer.toString());
226 }
227 catch (Error e)
228 {
229
230 }
231
232
233 input = "${no such name}";
234 buffer = new StringBuilder(input);
235
236 prof.resolve(buffer, doc);
237 assertEquals(input, buffer.toString());
238
239
240 input = "${no such section/no such name}";
241 buffer = new StringBuilder(input);
242
243 prof.resolve(buffer, doc);
244 assertEquals(input, buffer.toString());
245
246
247 input = "${happy/no such name}";
248 buffer = new StringBuilder(input);
249
250 prof.resolve(buffer, doc);
251 assertEquals(input, buffer.toString());
252
253
254 input = "${";
255 buffer = new StringBuilder(input);
256
257 prof.resolve(buffer, doc);
258 assertEquals(input, buffer.toString());
259
260
261 input = "${doc/weight";
262 buffer = new StringBuilder(input);
263
264 prof.resolve(buffer, doc);
265 assertEquals(input, buffer.toString());
266
267
268 input = "jim${}";
269 buffer = new StringBuilder(input);
270
271 prof.resolve(buffer, doc);
272 assertEquals(input, buffer.toString());
273
274
275 input = "${happy/weight}";
276 buffer = new StringBuilder(input);
277
278 prof.resolve(buffer, doc);
279 assertEquals("" + DwarfsData.happy.weight, buffer.toString());
280 input = "\\" + input;
281 buffer = new StringBuilder(input);
282
283 prof.resolve(buffer, doc);
284 assertEquals(input, buffer.toString());
285 }
286
287 @Test public void testResolveArray() throws Exception
288 {
289 StringBuilder buffer;
290 BasicProfile prof = new BasicProfile();
291
292 prof.add(SECTION).add(NUMBER, 1);
293 prof.add(SECTION).add(NUMBER, 2);
294 Profile.Section sec = prof.get(SECTION);
295
296
297 buffer = new StringBuilder("${section[0]/number}");
298 prof.resolve(buffer, sec);
299 assertEquals("1", buffer.toString());
300 buffer = new StringBuilder("${section[1]/number}");
301 prof.resolve(buffer, sec);
302 assertEquals("2", buffer.toString());
303 buffer = new StringBuilder("${section[0]/number}-${section[1]/number}");
304 prof.resolve(buffer, sec);
305 assertEquals("1-2", buffer.toString());
306
307
308 prof.clear();
309 sec = prof.add(SECTION);
310 sec.add(NUMBER, 1);
311 sec.add(NUMBER, 2);
312 sec = prof.get(SECTION);
313 assertEquals(2, sec.length(NUMBER));
314 buffer = new StringBuilder("${number}");
315 prof.resolve(buffer, sec);
316 assertEquals("2", buffer.toString());
317 buffer = new StringBuilder("${number[0]}-${section/number[1]}-${section[0]/number}");
318 prof.resolve(buffer, sec);
319 assertEquals("1-2-2", buffer.toString());
320 }
321
322 @Test public void testSectionArray() throws Exception
323 {
324 BasicProfile prof = new BasicProfile();
325
326 prof.add(SECTION).add(NUMBER, 1);
327 prof.add(SECTION).add(NUMBER, 2);
328 prof.add(SINGLE).add(NUMBER, 3);
329 Global g = prof.as(Global.class);
330
331 assertNotNull(g);
332 assertEquals(2, g.getSection().length);
333 assertEquals(1, g.getSingle().length);
334 assertNull(g.getMissing());
335 assertTrue(g.hasSection());
336 }
337
338 @Test public void testSetter()
339 {
340 BasicProfile prof = new BasicProfile();
341 Global g = prof.as(Global.class);
342 Section s1 = new SectionBean();
343 Section s2 = new SectionBean();
344 Section[] all = new Section[] { s1, s2 };
345
346 g.setSection(all);
347 assertEquals(2, prof.length("section"));
348 assertNull(g.getSolo());
349 g.setSolo(s1);
350 assertNotNull(g.getSolo());
351 g.setSolo(null);
352 assertEquals(0, prof.length("solo"));
353 }
354
355 private void fromToAs(BasicProfile prof, DwarfData dwarf)
356 {
357 Profile.Section sec = prof.get(dwarf.name);
358 Profile.Section dup = new BasicProfileSection(prof, SECTION);
359 DwarfBean bean = new DwarfBean();
360
361 sec.to(bean);
362 Helper.assertEquals(dwarf, bean);
363 dup.from(bean);
364 bean = new DwarfBean();
365 dup.to(bean);
366 Helper.assertEquals(dwarf, bean);
367 Dwarf proxy = dup.as(Dwarf.class);
368
369 Helper.assertEquals(dwarf, proxy);
370 dup.clear();
371 sec.to(proxy);
372 Helper.assertEquals(dwarf, proxy);
373 prof.remove(dup);
374 }
375
376 public static interface DwarfsRW extends Dwarfs
377 {
378 void setBashful(Dwarf value);
379 }
380
381 public static interface Global
382 {
383 Section[] getMissing();
384
385 Section[] getSection();
386
387 void setSection(Section[] value);
388
389 Section[] getSingle();
390
391 Section getSolo();
392
393 void setSolo(Section value);
394
395 boolean hasSection();
396 }
397
398 public static interface Section
399 {
400 URI[] getLocation();
401
402 void setLocation(URI[] value);
403
404 String[] getMissing();
405
406 void setMissing(String[] value);
407
408 int[] getNumber();
409
410 void setNumber(int[] value);
411 }
412
413 public static class SectionBean implements Section
414 {
415 private URI[] _location;
416 private String[] _missing;
417 private int[] _number;
418
419 @Override public URI[] getLocation()
420 {
421 return _location;
422 }
423
424 @Override public void setLocation(URI[] value)
425 {
426 _location = value;
427 }
428
429 @Override public String[] getMissing()
430 {
431 return _missing;
432 }
433
434 @Override public void setMissing(String[] value)
435 {
436 _missing = value;
437 }
438
439 @Override public int[] getNumber()
440 {
441 return _number;
442 }
443
444 @Override public void setNumber(int[] value)
445 {
446 _number = value;
447 }
448 }
449 }