1   package ch.qos.logback.core.joran.spi;
2   
3   import static org.junit.Assert.assertEquals;
4   import static org.junit.Assert.assertNotNull;
5   import static org.junit.Assert.assertTrue;
6   
7   import java.lang.reflect.Method;
8   import java.util.ArrayList;
9   import java.util.List;
10  
11  import org.junit.Test;
12  
13  import ch.qos.logback.core.Context;
14  import ch.qos.logback.core.ContextBase;
15  import ch.qos.logback.core.spi.FilterReply;
16  import ch.qos.logback.core.util.AggregationType;
17  import ch.qos.logback.core.util.Duration;
18  import ch.qos.logback.core.util.FileSize;
19  
20  public class PropertySetterTest {
21  
22    DefaultNestedComponentRegistry defaultComponentRegistry = new DefaultNestedComponentRegistry();
23  
24    @Test
25    public void testCanAggregateComponent() {
26      House house = new House();
27      PropertySetter setter = new PropertySetter(house);
28      assertEquals(AggregationType.AS_COMPLEX_PROPERTY, setter
29          .computeAggregationType("door"));
30  
31      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
32          .computeAggregationType("count"));
33      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
34          .computeAggregationType("Count"));
35  
36      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
37          .computeAggregationType("name"));
38      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
39          .computeAggregationType("Name"));
40  
41      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
42          .computeAggregationType("Duration"));
43      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
44          .computeAggregationType("fs"));
45  
46      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
47          .computeAggregationType("open"));
48      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
49          .computeAggregationType("Open"));
50  
51      assertEquals(AggregationType.AS_COMPLEX_PROPERTY_COLLECTION, setter
52          .computeAggregationType("Window"));
53      assertEquals(AggregationType.AS_BASIC_PROPERTY_COLLECTION, setter
54          .computeAggregationType("adjective"));
55  
56      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
57          .computeAggregationType("filterReply"));
58      assertEquals(AggregationType.AS_BASIC_PROPERTY, setter
59          .computeAggregationType("houseColor"));
60  
61      System.out.println();
62    }
63  
64    @Test
65    public void testSetProperty() {
66      {
67        House house = new House();
68        PropertySetter setter = new PropertySetter(house);
69        setter.setProperty("count", "10");
70        setter.setProperty("name", "jack");
71        setter.setProperty("open", "true");
72  
73        assertEquals(10, house.getCount());
74        assertEquals("jack", house.getName());
75        assertTrue(house.isOpen());
76      }
77  
78      {
79        House house = new House();
80        PropertySetter setter = new PropertySetter(house);
81        setter.setProperty("Count", "10");
82        setter.setProperty("Name", "jack");
83        setter.setProperty("Open", "true");
84  
85        assertEquals(10, house.getCount());
86        assertEquals("jack", house.getName());
87        assertTrue(house.isOpen());
88      }
89    }
90  
91    @Test
92    public void testSetCamelProperty() {
93      House house = new House();
94      PropertySetter setter = new PropertySetter(house);
95  
96      setter.setProperty("camelCase", "trot");
97      assertEquals("trot", house.getCamelCase());
98  
99      setter.setProperty("camelCase", "gh");
100     assertEquals("gh", house.getCamelCase());
101   }
102 
103   @Test
104   public void testSetComplexProperty() {
105     House house = new House();
106     Door door = new Door();
107     PropertySetter setter = new PropertySetter(house);
108     setter.setComplexProperty("door", door);
109     assertEquals(door, house.getDoor());
110   }
111 
112   @Test
113   public void testgetClassNameViaImplicitRules() {
114     House house = new House();
115     PropertySetter setter = new PropertySetter(house);
116     Class compClass = setter.getClassNameViaImplicitRules("door",
117         AggregationType.AS_COMPLEX_PROPERTY, defaultComponentRegistry);
118     assertEquals(Door.class, compClass);
119   }
120 
121   @Test
122   public void testgetComplexPropertyColleClassNameViaImplicitRules() {
123     House house = new House();
124     PropertySetter setter = new PropertySetter(house);
125     Class compClass = setter.getClassNameViaImplicitRules("window",
126         AggregationType.AS_COMPLEX_PROPERTY_COLLECTION,
127         defaultComponentRegistry);
128     assertEquals(Window.class, compClass);
129   }
130 
131   @Test
132   public void testPropertyCollection() {
133     House house = new House();
134     Context context = new ContextBase();
135     PropertySetter setter = new PropertySetter(house);
136     setter.setContext(context);
137     setter.addBasicProperty("adjective", "nice");
138     setter.addBasicProperty("adjective", "big");
139 
140     assertEquals(2, house.adjectiveList.size());
141     assertEquals("nice", house.adjectiveList.get(0));
142     assertEquals("big", house.adjectiveList.get(1));
143   }
144 
145   @Test
146   public void testComplexCollection() {
147     House house = new House();
148     PropertySetter setter = new PropertySetter(house);
149     Window w1 = new Window();
150     w1.handle = 10;
151     Window w2 = new Window();
152     w2.handle = 20;
153 
154     setter.addComplexProperty("window", w1);
155     setter.addComplexProperty("window", w2);
156     assertEquals(2, house.windowList.size());
157     assertEquals(10, house.windowList.get(0).handle);
158     assertEquals(20, house.windowList.get(1).handle);
159   }
160 
161   @Test
162   public void testSetComplexWithCamelCaseName() {
163     House house = new House();
164     SwimmingPool pool = new SwimmingPoolImpl();
165     PropertySetter setter = new PropertySetter(house);
166     setter.setComplexProperty("swimmingPool", pool);
167     assertEquals(pool, house.getSwimmingPool());
168   }
169 
170   @Test
171   public void testDuration() {
172     House house = new House();
173     PropertySetter setter = new PropertySetter(house);
174     setter.setProperty("duration", "1.4 seconds");
175     assertEquals(1400, house.getDuration().getMilliseconds());
176   }
177 
178   @Test
179   public void testFileSize() {
180     House house = new House();
181     PropertySetter setter = new PropertySetter(house);
182     setter.setProperty("fs", "2 kb");
183     assertEquals(2 * 1024, house.getFs().getSize());
184   }
185 
186   @Test
187   public void testFilterReply() {
188     // test case reproducing bug #52
189     House house = new House();
190     PropertySetter setter = new PropertySetter(house);
191     setter.setProperty("filterReply", "ACCEPT");
192     assertEquals(FilterReply.ACCEPT, house.getFilterReply());
193   }
194 
195   @Test
196   public void testEnum() {
197     House house = new House();
198     PropertySetter setter = new PropertySetter(house);
199     setter.setProperty("houseColor", "BLUE");
200     assertEquals(HouseColor.BLUE, house.getHouseColor());
201   }
202 
203   @Test
204   public void testDefaultClassAnnonation() {
205     House house = new House();
206     PropertySetter setter = new PropertySetter(house);
207     Method relevantMethod = setter.getRelevantMethod("SwimmingPool",
208         AggregationType.AS_COMPLEX_PROPERTY);
209     assertNotNull(relevantMethod);
210     Class spClass = setter.getDefaultClassNameByAnnonation("SwimmingPool",
211         relevantMethod);
212     assertEquals(SwimmingPoolImpl.class, spClass);
213 
214     Class classViaImplicitRules = setter.getClassNameViaImplicitRules(
215         "SwimmingPool", AggregationType.AS_COMPLEX_PROPERTY,
216         defaultComponentRegistry);
217     assertEquals(SwimmingPoolImpl.class, classViaImplicitRules);
218   }
219   
220   @Test
221   public void testDefaultClassAnnotationForLists() {
222     House house = new House();
223     PropertySetter setter = new PropertySetter(house);
224     Method relevantMethod = setter.getRelevantMethod("LargeSwimmingPool",
225         AggregationType.AS_COMPLEX_PROPERTY_COLLECTION);
226     assertNotNull(relevantMethod);
227     Class spClass = setter.getDefaultClassNameByAnnonation("LargeSwimmingPool",
228         relevantMethod);
229     assertEquals(LargeSwimmingPoolImpl.class, spClass);
230 
231     Class classViaImplicitRules = setter.getClassNameViaImplicitRules(
232         "LargeSwimmingPool", AggregationType.AS_COMPLEX_PROPERTY_COLLECTION,
233         defaultComponentRegistry);
234     assertEquals(LargeSwimmingPoolImpl.class, classViaImplicitRules);
235     
236   }
237 }
238 
239 class House {
240   Door mainDoor;
241   int count;
242   boolean open;
243   String name;
244   String camelCase;
245   SwimmingPool pool;
246   Duration duration;
247   FileSize fs;
248   HouseColor houseColor;
249   FilterReply reply;
250 
251   List<String> adjectiveList = new ArrayList<String>();
252   List<Window> windowList = new ArrayList<Window>();
253   List<SwimmingPool> largePoolList = new ArrayList<SwimmingPool>();
254 
255   public String getCamelCase() {
256     return camelCase;
257   }
258 
259   public void setCamelCase(String camelCase) {
260     this.camelCase = camelCase;
261   }
262 
263   public int getCount() {
264     return count;
265   }
266 
267   public void setCount(int c) {
268     this.count = c;
269   }
270 
271   public Door getDoor() {
272     return mainDoor;
273   }
274 
275   public void setDoor(Door door) {
276     this.mainDoor = door;
277   }
278 
279   public String getName() {
280     return name;
281   }
282 
283   public void setName(String name) {
284     this.name = name;
285   }
286 
287   public boolean isOpen() {
288     return open;
289   }
290 
291   public void setOpen(boolean open) {
292     this.open = open;
293   }
294 
295   @DefaultClass(LargeSwimmingPoolImpl.class)
296   public void addLargeSwimmingPool(SwimmingPool pool) {
297     this.pool = pool;
298   }
299 
300   @DefaultClass(SwimmingPoolImpl.class)
301   public void setSwimmingPool(SwimmingPool pool) {
302     this.pool = pool;
303   }
304 
305   public SwimmingPool getSwimmingPool() {
306     return pool;
307   }
308 
309   public void addWindow(Window w) {
310     windowList.add(w);
311   }
312 
313   public void addAdjective(String s) {
314     adjectiveList.add(s);
315   }
316 
317   public Duration getDuration() {
318     return duration;
319   }
320 
321   public void setDuration(Duration duration) {
322     this.duration = duration;
323   }
324 
325   public FileSize getFs() {
326     return fs;
327   }
328 
329   public void setFs(FileSize fs) {
330     this.fs = fs;
331   }
332 
333   public void setHouseColor(HouseColor color) {
334     this.houseColor = color;
335   }
336 
337   public HouseColor getHouseColor() {
338     return houseColor;
339   }
340 
341   public void setFilterReply(FilterReply reply) {
342     this.reply = reply;
343   }
344 
345   public FilterReply getFilterReply() {
346     return reply;
347   }
348 
349 }
350 
351 class Door {
352   int handle;
353 }
354 
355 class Window {
356   int handle;
357 }
358 
359 interface SwimmingPool {
360 }
361 
362 class SwimmingPoolImpl implements SwimmingPool {
363   int length;
364   int width;
365   int depth;
366 }
367 
368 class LargeSwimmingPoolImpl implements SwimmingPool {
369   int length;
370   int width;
371   int depth;
372 }
373 
374 enum HouseColor {
375   WHITE, BLUE
376 }