1   /**
2    * Logback: the generic, reliable, fast and flexible logging framework.
3    * 
4    * Copyright (C) 1999-2006, QOS.ch
5    * 
6    * This library is free software, you can redistribute it and/or modify it under
7    * the terms of the GNU Lesser General Public License as published by the Free
8    * Software Foundation.
9    */
10  package ch.qos.logback.core.pattern.parser;
11  
12  import static org.junit.Assert.assertEquals;
13  import static org.junit.Assert.assertTrue;
14  
15  import java.util.HashMap;
16  import java.util.Map;
17  
18  import org.junit.Before;
19  import org.junit.Test;
20  
21  import ch.qos.logback.core.Context;
22  import ch.qos.logback.core.ContextBase;
23  import ch.qos.logback.core.pattern.Converter;
24  import ch.qos.logback.core.pattern.Converter123;
25  import ch.qos.logback.core.pattern.ConverterHello;
26  import ch.qos.logback.core.status.StatusChecker;
27  import ch.qos.logback.core.util.StatusPrinter;
28  
29  
30  public class CompilerTest  {
31  
32    Map<String, String> converterMap = new HashMap<String, String>();
33    Context context = new ContextBase();
34    
35    @Before public void setUp() {
36      converterMap.put("OTT", Converter123.class.getName());
37      converterMap.put("hello", ConverterHello.class.getName());
38    }
39  
40  
41    String write(final Converter<Object> head, Object event) {
42      StringBuffer buf = new StringBuffer();
43      Converter<Object> c = head;
44      while (c != null) {
45        c.write(buf, event);
46        c = c.getNext();
47      }
48      return buf.toString();
49    }
50  
51    @Test
52    public void testLiteral() throws Exception {
53      Parser<Object> p = new Parser<Object>("hello");
54      Node t = p.parse();
55      Converter<Object> head = p.compile(t, converterMap);
56      String result = write(head, new Object());
57      assertEquals("hello", result);
58    }
59  
60    @Test
61    public void testBasic() throws Exception {
62      {
63        Parser<Object> p = new Parser<Object>("abc %hello");
64        p.setContext(context);
65        Node t = p.parse();
66        Converter<Object> head = p.compile(t, converterMap);
67        String result = write(head, new Object());
68        assertEquals("abc Hello", result); 
69      }
70      {
71        Parser<Object> p = new Parser<Object>("abc %hello %OTT");
72        p.setContext(context);
73        Node t = p.parse();
74        Converter<Object> head = p.compile(t, converterMap);
75        String result = write(head, new Object());
76        assertEquals("abc Hello 123", result);
77      }
78    }
79  
80    @Test
81    public void testFormat() throws Exception {
82      {
83        Parser<Object> p = new Parser<Object>("abc %7hello");
84        p.setContext(context);
85        Node t = p.parse();
86        Converter<Object> head = p.compile(t, converterMap);
87        String result = write(head, new Object());
88        assertEquals("abc   Hello", result);
89      }
90  
91      {
92        Parser<Object> p = new Parser<Object>("abc %-7hello");
93        p.setContext(context);
94        Node t = p.parse();
95        Converter<Object> head = p.compile(t, converterMap);
96        String result = write(head, new Object());
97        assertEquals("abc Hello  ", result);
98      }
99  
100     {
101       Parser<Object> p = new Parser<Object>("abc %.3hello");
102       p.setContext(context);
103       Node t = p.parse();
104       Converter<Object> head = p.compile(t, converterMap);
105       String result = write(head, new Object());
106       assertEquals("abc llo", result);
107     }
108 
109     {
110       Parser<Object> p = new Parser<Object>("abc %.-3hello");
111       p.setContext(context);
112       Node t = p.parse();
113       Converter<Object> head = p.compile(t, converterMap);
114       String result = write(head, new Object());
115       assertEquals("abc Hel", result);
116     }
117 
118     {
119       Parser<Object> p = new Parser<Object>("abc %4.5OTT");
120       p.setContext(context);
121       Node t = p.parse();
122       Converter<Object> head = p.compile(t, converterMap);
123       String result = write(head, new Object());
124       assertEquals("abc  123", result);
125     }
126     {
127       Parser<Object> p = new Parser<Object>("abc %-4.5OTT");
128       p.setContext(context);
129       Node t = p.parse();
130       Converter<Object> head = p.compile(t, converterMap);
131       String result = write(head, new Object());
132       assertEquals("abc 123 ", result);
133     }
134     {
135       Parser<Object> p = new Parser<Object>("abc %3.4hello");
136       p.setContext(context);
137       Node t = p.parse();
138       Converter<Object> head = p.compile(t, converterMap);
139       String result = write(head, new Object());
140       assertEquals("abc ello", result);
141     }
142     {
143       Parser<Object> p = new Parser<Object>("abc %-3.-4hello");
144       p.setContext(context);
145       Node t = p.parse();
146       Converter<Object> head = p.compile(t, converterMap);
147       String result = write(head, new Object());
148       assertEquals("abc Hell", result);
149     }
150   }
151 
152   @Test
153   public void testComposite() throws Exception {
154 //    {
155 //      Parser<Object> p = new Parser<Object>("%(ABC)");
156 //      p.setContext(context);
157 //      Node t = p.parse();
158 //      Converter<Object> head = p.compile(t, converterMap);
159 //      String result = write(head, new Object());
160 //      assertEquals("ABC", result);
161 //    }
162     {
163       Context c = new ContextBase();
164       Parser<Object> p = new Parser<Object>("%(ABC %hello)");
165       p.setContext(c);
166       Node t = p.parse();
167       Converter<Object> head = p.compile(t, converterMap);
168       String result = write(head, new Object());
169       StatusPrinter.print(c);
170       assertEquals("ABC Hello", result);
171     }
172     {
173       Parser<Object> p = new Parser<Object>("%(ABC %hello)");
174       p.setContext(context);
175       Node t = p.parse();
176       Converter<Object> head = p.compile(t, converterMap);
177       String result = write(head, new Object());
178       assertEquals("ABC Hello", result);
179     }
180   }
181 
182   @Test
183   public void testCompositeFormatting() throws Exception {
184     {
185       Parser<Object> p = new Parser<Object>("xyz %4.10(ABC)");
186       p.setContext(context);
187       Node t = p.parse();
188       Converter<Object> head = p.compile(t, converterMap);
189       String result = write(head, new Object());
190       assertEquals("xyz  ABC", result);
191     }
192 
193     {
194       Parser<Object> p = new Parser<Object>("xyz %-4.10(ABC)");
195       p.setContext(context);
196       Node t = p.parse();
197       Converter<Object> head = p.compile(t, converterMap);
198       String result = write(head, new Object());
199       assertEquals("xyz ABC ", result);
200     }
201 
202     {
203       Parser<Object> p = new Parser<Object>("xyz %.2(ABC %hello)");
204       p.setContext(context);
205       Node t = p.parse();
206       Converter<Object> head = p.compile(t, converterMap);
207       String result = write(head, new Object());
208       assertEquals("xyz lo", result);
209     }
210 
211     {
212       Parser<Object> p = new Parser<Object>("xyz %.-2(ABC)");
213       p.setContext(context);
214       Node t = p.parse();
215       Converter<Object> head = p.compile(t, converterMap);
216       String result = write(head, new Object());
217       assertEquals("xyz AB", result);
218     }
219 
220     {
221       Parser<Object> p = new Parser<Object>("xyz %30.30(ABC %20hello)");
222       p.setContext(context);
223       Node t = p.parse();
224       Converter<Object> head = p.compile(t, converterMap);
225       String result = write(head, new Object());
226       assertEquals("xyz       ABC                Hello", result);
227     }
228   }
229 
230   @Test
231   public void testUnknownWord() throws Exception {
232     Parser<Object> p = new Parser<Object>("%unknown");
233     p.setContext(context);
234     Node t = p.parse();
235     p.compile(t, converterMap);
236     StatusChecker chercker = new StatusChecker(context.getStatusManager());
237     assertTrue(chercker
238         .containsMatch("\\[unknown] is not a valid conversion word"));
239   }
240 
241   @Test
242   public void testWithNopEscape() throws Exception {
243     {
244       Parser<Object> p = new Parser<Object>("xyz %hello\\_world");
245       p.setContext(context);
246       Node t = p.parse();
247       Converter<Object> head = p.compile(t, converterMap);
248       String result = write(head, new Object());
249       assertEquals("xyz Helloworld", result);
250     }
251   }
252 
253 }