001 /* 002 * Copyright 2005,2009 Ivan SZKIBA 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 package org.ini4j; 017 018 import org.ini4j.sample.Dwarf; 019 import org.ini4j.sample.DwarfBean; 020 import org.ini4j.sample.Dwarfs; 021 022 import org.ini4j.test.DwarfsData; 023 import org.ini4j.test.DwarfsData.DwarfData; 024 import org.ini4j.test.Helper; 025 026 import static org.junit.Assert.assertEquals; 027 import static org.junit.Assert.assertNotNull; 028 import static org.junit.Assert.assertNull; 029 import static org.junit.Assert.assertTrue; 030 031 import org.junit.Test; 032 033 import java.net.URI; 034 035 public class BasicProfileTest extends Ini4jCase 036 { 037 private static final String SECTION = "section"; 038 private static final String NUMBER = "number"; 039 private static final String SINGLE = "single"; 040 private static final String SOLO = "solo"; 041 private static final String LOCATION = "location"; 042 private static final String LOCATION_1 = "http://www.ini4j.org"; 043 private static final String LOCATION_2 = "http://ini4j.org"; 044 045 /* 046 * thanx to Gary Pampara for bug report 047 */ 048 @Test public void bug_2817403() throws Exception 049 { 050 BasicProfile prof = new BasicProfile(); 051 Profile.Section sec = prof.add("section"); 052 053 sec.add("player.name", "Joe"); 054 sec.add("player.greeting", "Hi ${player.name}!"); 055 sec.add("player.domain", "foo.bar"); 056 sec.add("player.email", "${player.name}@${player.domain}"); 057 058 // 059 assertEquals("Joe", sec.fetch("player.name")); 060 assertEquals("Hi Joe!", sec.fetch("player.greeting")); 061 assertEquals("foo.bar", sec.fetch("player.domain")); 062 assertEquals("Joe@foo.bar", sec.fetch("player.email")); 063 064 // 065 sec = prof.add("other"); 066 sec.add("option", "${section/player.name}"); 067 assertEquals("Joe", sec.fetch("option")); 068 sec.put("option", "${section/player.email}"); 069 assertEquals("Joe@foo.bar", sec.fetch("option")); 070 sec.put("option2", "${option} ${section/player.name} ${section/player.domain}"); 071 assertEquals("Joe@foo.bar Joe foo.bar", sec.fetch("option2")); 072 } 073 074 @Test public void testAddPut() 075 { 076 Profile prof = new BasicProfile(); 077 078 prof.add(SECTION, Dwarf.PROP_AGE, DwarfsData.sneezy.age); 079 prof.put(SECTION, Dwarf.PROP_HEIGHT, DwarfsData.sneezy.height); 080 prof.add(SECTION, Dwarf.PROP_HOME_DIR, DwarfsData.sneezy.homeDir); 081 prof.add(SECTION, Dwarf.PROP_WEIGHT, DwarfsData.sneezy.weight); 082 prof.put(SECTION, Dwarf.PROP_HOME_PAGE, null); 083 prof.put(SECTION, Dwarf.PROP_HOME_PAGE, DwarfsData.sneezy.homePage); 084 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[0]); 085 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[1]); 086 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[2]); 087 prof.add(SECTION, Dwarf.PROP_FORTUNE_NUMBER, DwarfsData.sneezy.fortuneNumber[3]); 088 Helper.assertEquals(DwarfsData.sneezy, prof.get(SECTION).as(Dwarf.class)); 089 assertNotNull(prof.remove(SECTION, Dwarf.PROP_FORTUNE_NUMBER)); 090 assertEquals(0, prof.get(SECTION).length(Dwarf.PROP_FORTUNE_NUMBER)); 091 assertNotNull(prof.remove(SECTION)); 092 assertNull(prof.remove(SECTION, Dwarf.PROP_FORTUNE_NUMBER)); 093 } 094 095 @Test public void testFirstUpper() 096 { 097 BasicProfile prof = new BasicProfile(true, true); 098 DwarfsRW dwarfs = prof.as(DwarfsRW.class); 099 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 // nulls 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 // other sections's value 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 // same sections's value 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 // system property 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 // system environment 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 // retroweaver + JDK 1.4 throws Error on getenv 230 } 231 232 // unknown variable 233 input = "${no such name}"; 234 buffer = new StringBuilder(input); 235 236 prof.resolve(buffer, doc); 237 assertEquals(input, buffer.toString()); 238 239 // unknown section's unknown variable 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 // other section's unknown variable 247 input = "${happy/no such name}"; 248 buffer = new StringBuilder(input); 249 250 prof.resolve(buffer, doc); 251 assertEquals(input, buffer.toString()); 252 253 // small input 254 input = "${"; 255 buffer = new StringBuilder(input); 256 257 prof.resolve(buffer, doc); 258 assertEquals(input, buffer.toString()); 259 260 // incorrect references 261 input = "${doc/weight"; 262 buffer = new StringBuilder(input); 263 264 prof.resolve(buffer, doc); 265 assertEquals(input, buffer.toString()); 266 267 // empty references 268 input = "jim${}"; 269 buffer = new StringBuilder(input); 270 271 prof.resolve(buffer, doc); 272 assertEquals(input, buffer.toString()); 273 274 // escaped references 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 }