1
2
3
4
5
6
7
8
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
156
157
158
159
160
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 }