1
2
3
4
5
6
7
8
9
10
11
12
13
14 package ch.qos.logback.core.pattern.parser;
15
16 import ch.qos.logback.core.Context;
17 import ch.qos.logback.core.ContextBase;
18 import ch.qos.logback.core.pattern.Converter;
19 import ch.qos.logback.core.pattern.Converter123;
20 import ch.qos.logback.core.pattern.ConverterHello;
21 import ch.qos.logback.core.pattern.DynamicConverter;
22 import ch.qos.logback.core.status.testUtil.StatusChecker;
23
24 import org.junit.jupiter.api.BeforeEach;
25 import org.junit.jupiter.api.Test;
26
27 import java.util.HashMap;
28 import java.util.Map;
29 import java.util.function.Supplier;
30
31 import static org.junit.jupiter.api.Assertions.assertEquals;
32
33 public class CompilerTest {
34
35 Map<String, Supplier<DynamicConverter>> converterMap = new HashMap<>();
36 Context context = new ContextBase();
37
38 @BeforeEach
39 public void setUp() {
40 converterMap.put("OTT", Converter123::new);
41 converterMap.put("hello", ConverterHello::new);
42 converterMap.putAll(Parser.DEFAULT_COMPOSITE_CONVERTER_MAP);
43 }
44
45 String write(final Converter<Object> head, Object event) {
46 StringBuilder buf = new StringBuilder();
47 Converter<Object> c = head;
48 while (c != null) {
49 c.write(buf, event);
50 c = c.getNext();
51 }
52 return buf.toString();
53 }
54
55 @Test
56 public void testLiteral() throws Exception {
57 Parser<Object> p = new Parser<Object>("hello");
58 Node t = p.parse();
59 Converter<Object> head = p.compile(t, converterMap);
60 String result = write(head, new Object());
61 assertEquals("hello", result);
62 }
63
64 @Test
65 public void testBasic() throws Exception {
66 {
67 Parser<Object> p = new Parser<Object>("abc %hello");
68 p.setContext(context);
69 Node t = p.parse();
70 Converter<Object> head = p.compile(t, converterMap);
71 String result = write(head, new Object());
72 assertEquals("abc Hello", result);
73 }
74 {
75 Parser<Object> p = new Parser<Object>("abc %hello %OTT");
76 p.setContext(context);
77 Node t = p.parse();
78 Converter<Object> head = p.compile(t, converterMap);
79 String result = write(head, new Object());
80 assertEquals("abc Hello 123", result);
81 }
82 }
83
84 @Test
85 public void converterStart() throws Exception {
86 {
87 Parser<Object> p = new Parser<Object>("abc %hello");
88 p.setContext(context);
89 Node t = p.parse();
90 Converter<Object> head = p.compile(t, converterMap);
91 String result = write(head, new Object());
92 assertEquals("abc Hello", result);
93 }
94 }
95
96 @Test
97 public void testFormat() throws Exception {
98 {
99 Parser<Object> p = new Parser<Object>("abc %7hello");
100 p.setContext(context);
101 Node t = p.parse();
102 Converter<Object> head = p.compile(t, converterMap);
103 String result = write(head, new Object());
104 assertEquals("abc Hello", result);
105 }
106
107 {
108 Parser<Object> p = new Parser<Object>("abc %-7hello");
109 p.setContext(context);
110 Node t = p.parse();
111 Converter<Object> head = p.compile(t, converterMap);
112 String result = write(head, new Object());
113 assertEquals("abc Hello ", result);
114 }
115
116 {
117 Parser<Object> p = new Parser<Object>("abc %.3hello");
118 p.setContext(context);
119 Node t = p.parse();
120 Converter<Object> head = p.compile(t, converterMap);
121 String result = write(head, new Object());
122 assertEquals("abc llo", result);
123 }
124
125 {
126 Parser<Object> p = new Parser<Object>("abc %.-3hello");
127 p.setContext(context);
128 Node t = p.parse();
129 Converter<Object> head = p.compile(t, converterMap);
130 String result = write(head, new Object());
131 assertEquals("abc Hel", result);
132 }
133
134 {
135 Parser<Object> p = new Parser<Object>("abc %4.5OTT");
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 123", result);
141 }
142 {
143 Parser<Object> p = new Parser<Object>("abc %-4.5OTT");
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 123 ", result);
149 }
150 {
151 Parser<Object> p = new Parser<Object>("abc %3.4hello");
152 p.setContext(context);
153 Node t = p.parse();
154 Converter<Object> head = p.compile(t, converterMap);
155 String result = write(head, new Object());
156 assertEquals("abc ello", result);
157 }
158 {
159 Parser<Object> p = new Parser<Object>("abc %-3.-4hello");
160 p.setContext(context);
161 Node t = p.parse();
162 Converter<Object> head = p.compile(t, converterMap);
163 String result = write(head, new Object());
164 assertEquals("abc Hell", result);
165 }
166 }
167
168 @Test
169 public void testComposite() throws Exception {
170
171
172
173
174
175
176
177
178 {
179 Context c = new ContextBase();
180 Parser<Object> p = new Parser<Object>("%(ABC %hello)");
181 p.setContext(c);
182 Node t = p.parse();
183 Converter<Object> head = p.compile(t, converterMap);
184 String result = write(head, new Object());
185
186 assertEquals("ABC Hello", result);
187 }
188 {
189 Parser<Object> p = new Parser<Object>("%(ABC %hello)");
190 p.setContext(context);
191 Node t = p.parse();
192 Converter<Object> head = p.compile(t, converterMap);
193 String result = write(head, new Object());
194 assertEquals("ABC Hello", result);
195 }
196 }
197
198 @Test
199 public void testCompositeFormatting() throws Exception {
200 {
201 Parser<Object> p = new Parser<Object>("xyz %4.10(ABC)");
202 p.setContext(context);
203 Node t = p.parse();
204 Converter<Object> head = p.compile(t, converterMap);
205 String result = write(head, new Object());
206 assertEquals("xyz ABC", result);
207 }
208
209 {
210 Parser<Object> p = new Parser<Object>("xyz %-4.10(ABC)");
211 p.setContext(context);
212 Node t = p.parse();
213 Converter<Object> head = p.compile(t, converterMap);
214 String result = write(head, new Object());
215 assertEquals("xyz ABC ", result);
216 }
217
218 {
219 Parser<Object> p = new Parser<Object>("xyz %.2(ABC %hello)");
220 p.setContext(context);
221 Node t = p.parse();
222 Converter<Object> head = p.compile(t, converterMap);
223 String result = write(head, new Object());
224 assertEquals("xyz lo", result);
225 }
226
227 {
228 Parser<Object> p = new Parser<Object>("xyz %.-2(ABC)");
229 p.setContext(context);
230 Node t = p.parse();
231 Converter<Object> head = p.compile(t, converterMap);
232 String result = write(head, new Object());
233 assertEquals("xyz AB", result);
234 }
235
236 {
237 Parser<Object> p = new Parser<Object>("xyz %30.30(ABC %20hello)");
238 p.setContext(context);
239 Node t = p.parse();
240 Converter<Object> head = p.compile(t, converterMap);
241 String result = write(head, new Object());
242 assertEquals("xyz ABC Hello", result);
243 }
244 }
245
246 @Test
247 public void testUnknownWord() throws Exception {
248 Parser<Object> p = new Parser<Object>("%unknown");
249 p.setContext(context);
250 Node t = p.parse();
251 p.compile(t, converterMap);
252 StatusChecker checker = new StatusChecker(context.getStatusManager());
253 checker.assertContainsMatch("\\[unknown] is not a valid conversion word");
254 }
255
256 @Test
257 public void testWithNopEscape() throws Exception {
258 {
259 Parser<Object> p = new Parser<Object>("xyz %hello\\_world");
260 p.setContext(context);
261 Node t = p.parse();
262 Converter<Object> head = p.compile(t, converterMap);
263 String result = write(head, new Object());
264 assertEquals("xyz Helloworld", result);
265 }
266 }
267
268 }