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  
14  import java.util.ArrayList;
15  import java.util.List;
16  
17  import org.junit.Test;
18  
19  import ch.qos.logback.core.pattern.FormatInfo;
20  
21  public class ParserTest {
22  
23    @Test
24    public void testBasic() throws Exception {
25      Parser p = new Parser("hello");
26      Node t = p.parse();
27      assertEquals(Node.LITERAL, t.getType());
28      assertEquals("hello", t.getValue());
29    }
30  
31    @Test
32    public void testKeyword() throws Exception {
33  
34      {
35        Parser p = new Parser("hello%xyz");
36        Node t = p.parse();
37        Node witness = new Node(Node.LITERAL, "hello");
38        witness.next = new KeywordNode("xyz");
39        assertEquals(witness, t);
40      }
41  
42      {
43        Parser p = new Parser("hello%xyz{x}");
44        Node t = p.parse();
45        Node witness = new Node(Node.LITERAL, "hello");
46        KeywordNode n = new KeywordNode("xyz");
47        List<String> optionList = new ArrayList<String>();
48        optionList.add("x");
49        n.setOptions(optionList);
50        witness.next = n;
51        assertEquals(witness, t);
52      }
53    }
54  
55    @Test
56    public void testComposite() throws Exception {
57      {
58        Parser p = new Parser("hello%(%child)");
59        Node t = p.parse();
60  
61        Node witness = new Node(Node.LITERAL, "hello");
62        CompositeNode composite = new CompositeNode();
63        Node child = new KeywordNode("child");
64        composite.setChildNode(child);
65        witness.next = composite;
66  
67        // System.out.println("w:" + witness);
68        // System.out.println(t);
69  
70        assertEquals(witness, t);
71      }
72  
73      // System.out.println("testRecursive part 2");
74      {
75        Parser p = new Parser("hello%(%child )");
76        Node t = p.parse();
77  
78        Node witness = new Node(Node.LITERAL, "hello");
79        CompositeNode composite = new CompositeNode();
80        Node child = new KeywordNode("child");
81        composite.setChildNode(child);
82        witness.next = composite;
83        child.next = new Node(Node.LITERAL, " ");
84        assertEquals(witness, t);
85      }
86  
87      {
88        Parser p = new Parser("hello%(%child %h)");
89        Node t = p.parse();
90        Node witness = new Node(Node.LITERAL, "hello");
91        CompositeNode composite = new CompositeNode();
92        Node child = new KeywordNode("child");
93        composite.setChildNode(child);
94        child.next = new Node(Node.LITERAL, " ");
95        child.next.next = new KeywordNode("h");
96        witness.next = composite;
97        assertEquals(witness, t);
98      }
99  
100     {
101       Parser p = new Parser("hello%(%child %h) %m");
102       Node t = p.parse();
103       Node witness = new Node(Node.LITERAL, "hello");
104       CompositeNode composite = new CompositeNode();
105       Node child = new KeywordNode("child");
106       composite.setChildNode(child);
107       child.next = new Node(Node.LITERAL, " ");
108       child.next.next = new KeywordNode("h");
109       witness.next = composite;
110       composite.next = new Node(Node.LITERAL, " ");
111       composite.next.next = new KeywordNode("m");
112       assertEquals(witness, t);
113     }
114 
115     {
116       Parser p = new Parser("hello%( %child \\(%h\\) ) %m");
117       Node t = p.parse();
118       Node witness = new Node(Node.LITERAL, "hello");
119       CompositeNode composite = new CompositeNode();
120       Node child = new Node(Node.LITERAL, " ");
121       composite.setChildNode(child);
122       Node c = child;
123       c = c.next = new KeywordNode("child");
124       c = c.next = new Node(Node.LITERAL, " (");
125       c = c.next = new KeywordNode("h");
126       c = c.next = new Node(Node.LITERAL, ") ");
127       witness.next = composite;
128       composite.next = new Node(Node.LITERAL, " ");
129       composite.next.next = new KeywordNode("m");
130       assertEquals(witness, t);
131 
132     }
133   }
134   
135   @Test
136   public void testNested() throws Exception {
137     {
138       Parser p = new Parser("%top %(%child%(%h))");
139       Node t = p.parse();
140       Node witness = new KeywordNode("top");
141       Node w = witness.next = new Node(Node.LITERAL, " ");
142       CompositeNode composite = new CompositeNode();
143       w = w.next = composite;
144       Node child = new KeywordNode("child");
145       composite.setChildNode(child);
146       composite = new CompositeNode();
147       child.next = composite;
148       composite.setChildNode(new KeywordNode("h"));
149 
150       assertEquals(witness, t);
151     }
152   }
153 
154   @Test
155   public void testFormattingInfo() throws Exception {
156     {
157       Parser p = new Parser("%45x");
158       Node t = p.parse();
159       FormattingNode witness = new KeywordNode("x");
160       witness.setFormatInfo(new FormatInfo(45, Integer.MAX_VALUE));
161       assertEquals(witness, t);
162     }
163     {
164       Parser p = new Parser("%4.5x");
165       Node t = p.parse();
166       FormattingNode witness = new KeywordNode("x");
167       witness.setFormatInfo(new FormatInfo(4, 5));
168       assertEquals(witness, t);
169     }
170 
171     {
172       Parser p = new Parser("%-4.5x");
173       Node t = p.parse();
174       FormattingNode witness = new KeywordNode("x");
175       witness.setFormatInfo(new FormatInfo(4, 5, false, true));
176       assertEquals(witness, t);
177     }
178     {
179       Parser p = new Parser("%-4.-5x");
180       Node t = p.parse();
181       FormattingNode witness = new KeywordNode("x");
182       witness.setFormatInfo(new FormatInfo(4, 5, false, false));
183       assertEquals(witness, t);
184     }
185 
186     {
187       Parser p = new Parser("%-4.5x %12y");
188       Node t = p.parse();
189       FormattingNode witness = new KeywordNode("x");
190       witness.setFormatInfo(new FormatInfo(4, 5, false, true));
191       Node n = witness.next = new Node(Node.LITERAL, " ");
192       n = n.next = new KeywordNode("y");
193       ((FormattingNode) n).setFormatInfo(new FormatInfo(12, Integer.MAX_VALUE));
194       assertEquals(witness, t);
195     }
196   }
197 
198   @Test
199   public void testOptions() throws Exception {
200     {
201       Parser p = new Parser("%45x{'test '}");
202       Node t = p.parse();
203       KeywordNode witness = new KeywordNode("x");
204       witness.setFormatInfo(new FormatInfo(45, Integer.MAX_VALUE));
205       List<String> ol = new ArrayList<String>();
206       ol.add("test ");
207       witness.setOptions(ol);
208       assertEquals(witness, t);
209     }
210 
211     {
212       Parser p = new Parser("%45x{a, b}");
213       Node t = p.parse();
214       KeywordNode witness = new KeywordNode("x");
215       witness.setFormatInfo(new FormatInfo(45, Integer.MAX_VALUE));
216       List<String> ol = new ArrayList<String>();
217       ol.add("a");
218       ol.add("b");
219       witness.setOptions(ol);
220       assertEquals(witness, t);
221     }
222   }
223 
224   @Test
225   public void testCompositeFormatting() throws Exception {
226 
227     {
228       Parser p = new Parser("hello%5(XYZ)");
229       Node t = p.parse();
230 
231       Node witness = new Node(Node.LITERAL, "hello");
232       CompositeNode composite = new CompositeNode();
233       composite.setFormatInfo(new FormatInfo(5, Integer.MAX_VALUE));
234       Node child = new Node(Node.LITERAL, "XYZ");
235       composite.setChildNode(child);
236       witness.next = composite;
237 
238       assertEquals(witness, t);
239     }
240   }
241 }