View Javadoc

1   /**
2    * Copyright (c) 2004-2011 QOS.ch
3    * All rights reserved.
4    *
5    * Permission is hereby granted, free  of charge, to any person obtaining
6    * a  copy  of this  software  and  associated  documentation files  (the
7    * "Software"), to  deal in  the Software without  restriction, including
8    * without limitation  the rights to  use, copy, modify,  merge, publish,
9    * distribute,  sublicense, and/or sell  copies of  the Software,  and to
10   * permit persons to whom the Software  is furnished to do so, subject to
11   * the following conditions:
12   *
13   * The  above  copyright  notice  and  this permission  notice  shall  be
14   * included in all copies or substantial portions of the Software.
15   *
16   * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
17   * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
18   * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
19   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20   * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21   * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
22   * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23   *
24   */
25  package org.slf4j.helpers;
26  
27  import java.util.Arrays;
28  
29  import org.junit.Test;
30  
31  import static org.junit.Assert.*;
32  
33  /**
34   * @author Ceki Gulcu
35   */
36  public class MessageFormatterTest {
37  
38      Integer i1 = new Integer(1);
39      Integer i2 = new Integer(2);
40      Integer i3 = new Integer(3);
41      Integer[] ia0 = new Integer[] { i1, i2, i3 };
42      Integer[] ia1 = new Integer[] { new Integer(10), new Integer(20), new Integer(30) };
43  
44      String result;
45  
46      @Test
47      public void testNull() {
48          result = MessageFormatter.format(null, i1).getMessage();
49          assertEquals(null, result);
50      }
51  
52      @Test
53      public void nullParametersShouldBeHandledWithoutBarfing() {
54          result = MessageFormatter.format("Value is {}.", null).getMessage();
55          assertEquals("Value is null.", result);
56  
57          result = MessageFormatter.format("Val1 is {}, val2 is {}.", null, null).getMessage();
58          assertEquals("Val1 is null, val2 is null.", result);
59  
60          result = MessageFormatter.format("Val1 is {}, val2 is {}.", i1, null).getMessage();
61          assertEquals("Val1 is 1, val2 is null.", result);
62  
63          result = MessageFormatter.format("Val1 is {}, val2 is {}.", null, i2).getMessage();
64          assertEquals("Val1 is null, val2 is 2.", result);
65  
66          result = MessageFormatter.arrayFormat("Val1 is {}, val2 is {}, val3 is {}", new Integer[] { null, null, null }).getMessage();
67          assertEquals("Val1 is null, val2 is null, val3 is null", result);
68  
69          result = MessageFormatter.arrayFormat("Val1 is {}, val2 is {}, val3 is {}", new Integer[] { null, i2, i3 }).getMessage();
70          assertEquals("Val1 is null, val2 is 2, val3 is 3", result);
71  
72          result = MessageFormatter.arrayFormat("Val1 is {}, val2 is {}, val3 is {}", new Integer[] { null, null, i3 }).getMessage();
73          assertEquals("Val1 is null, val2 is null, val3 is 3", result);
74      }
75  
76      @Test
77      public void verifyOneParameterIsHandledCorrectly() {
78          result = MessageFormatter.format("Value is {}.", i3).getMessage();
79          assertEquals("Value is 3.", result);
80  
81          result = MessageFormatter.format("Value is {", i3).getMessage();
82          assertEquals("Value is {", result);
83  
84          result = MessageFormatter.format("{} is larger than 2.", i3).getMessage();
85          assertEquals("3 is larger than 2.", result);
86  
87          result = MessageFormatter.format("No subst", i3).getMessage();
88          assertEquals("No subst", result);
89  
90          result = MessageFormatter.format("Incorrect {subst", i3).getMessage();
91          assertEquals("Incorrect {subst", result);
92  
93          result = MessageFormatter.format("Value is {bla} {}", i3).getMessage();
94          assertEquals("Value is {bla} 3", result);
95  
96          result = MessageFormatter.format("Escaped \\{} subst", i3).getMessage();
97          assertEquals("Escaped {} subst", result);
98  
99          result = MessageFormatter.format("{Escaped", i3).getMessage();
100         assertEquals("{Escaped", result);
101 
102         result = MessageFormatter.format("\\{}Escaped", i3).getMessage();
103         assertEquals("{}Escaped", result);
104 
105         result = MessageFormatter.format("File name is {{}}.", "App folder.zip").getMessage();
106         assertEquals("File name is {App folder.zip}.", result);
107 
108         // escaping the escape character
109         result = MessageFormatter.format("File name is C:\\\\{}.", "App folder.zip").getMessage();
110         assertEquals("File name is C:\\App folder.zip.", result);
111     }
112 
113     @Test
114     public void testTwoParameters() {
115         result = MessageFormatter.format("Value {} is smaller than {}.", i1, i2).getMessage();
116         assertEquals("Value 1 is smaller than 2.", result);
117 
118         result = MessageFormatter.format("Value {} is smaller than {}", i1, i2).getMessage();
119         assertEquals("Value 1 is smaller than 2", result);
120 
121         result = MessageFormatter.format("{}{}", i1, i2).getMessage();
122         assertEquals("12", result);
123 
124         result = MessageFormatter.format("Val1={}, Val2={", i1, i2).getMessage();
125         assertEquals("Val1=1, Val2={", result);
126 
127         result = MessageFormatter.format("Value {} is smaller than \\{}", i1, i2).getMessage();
128         assertEquals("Value 1 is smaller than {}", result);
129 
130         result = MessageFormatter.format("Value {} is smaller than \\{} tail", i1, i2).getMessage();
131         assertEquals("Value 1 is smaller than {} tail", result);
132 
133         result = MessageFormatter.format("Value {} is smaller than \\{", i1, i2).getMessage();
134         assertEquals("Value 1 is smaller than \\{", result);
135 
136         result = MessageFormatter.format("Value {} is smaller than {tail", i1, i2).getMessage();
137         assertEquals("Value 1 is smaller than {tail", result);
138 
139         result = MessageFormatter.format("Value \\{} is smaller than {}", i1, i2).getMessage();
140         assertEquals("Value {} is smaller than 1", result);
141     }
142 
143     @Test
144     public void testExceptionIn_toString() {
145         Object o = new Object() {
146             public String toString() {
147                 throw new IllegalStateException("a");
148             }
149         };
150         result = MessageFormatter.format("Troublesome object {}", o).getMessage();
151         assertEquals("Troublesome object [FAILED toString()]", result);
152 
153     }
154 
155     @Test
156     public void testNullArray() {
157         String msg0 = "msg0";
158         String msg1 = "msg1 {}";
159         String msg2 = "msg2 {} {}";
160         String msg3 = "msg3 {} {} {}";
161 
162         Object[] args = null;
163 
164         result = MessageFormatter.arrayFormat(msg0, args).getMessage();
165         assertEquals(msg0, result);
166 
167         result = MessageFormatter.arrayFormat(msg1, args).getMessage();
168         assertEquals(msg1, result);
169 
170         result = MessageFormatter.arrayFormat(msg2, args).getMessage();
171         assertEquals(msg2, result);
172 
173         result = MessageFormatter.arrayFormat(msg3, args).getMessage();
174         assertEquals(msg3, result);
175     }
176 
177     // tests the case when the parameters are supplied in a single array
178     @Test
179     public void testArrayFormat() {
180         result = MessageFormatter.arrayFormat("Value {} is smaller than {} and {}.", ia0).getMessage();
181         assertEquals("Value 1 is smaller than 2 and 3.", result);
182 
183         result = MessageFormatter.arrayFormat("{}{}{}", ia0).getMessage();
184         assertEquals("123", result);
185 
186         result = MessageFormatter.arrayFormat("Value {} is smaller than {}.", ia0).getMessage();
187         assertEquals("Value 1 is smaller than 2.", result);
188 
189         result = MessageFormatter.arrayFormat("Value {} is smaller than {}", ia0).getMessage();
190         assertEquals("Value 1 is smaller than 2", result);
191 
192         result = MessageFormatter.arrayFormat("Val={}, {, Val={}", ia0).getMessage();
193         assertEquals("Val=1, {, Val=2", result);
194 
195         result = MessageFormatter.arrayFormat("Val={}, {, Val={}", ia0).getMessage();
196         assertEquals("Val=1, {, Val=2", result);
197 
198         result = MessageFormatter.arrayFormat("Val1={}, Val2={", ia0).getMessage();
199         assertEquals("Val1=1, Val2={", result);
200     }
201 
202     @Test
203     public void testArrayValues() {
204         Integer p0 = i1;
205         Integer[] p1 = new Integer[] { i2, i3 };
206 
207         result = MessageFormatter.format("{}{}", p0, p1).getMessage();
208         assertEquals("1[2, 3]", result);
209 
210         // Integer[]
211         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", p1 }).getMessage();
212         assertEquals("a[2, 3]", result);
213 
214         // byte[]
215         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", new byte[] { 1, 2 } }).getMessage();
216         assertEquals("a[1, 2]", result);
217 
218         // int[]
219         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", new int[] { 1, 2 } }).getMessage();
220         assertEquals("a[1, 2]", result);
221 
222         // float[]
223         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", new float[] { 1, 2 } }).getMessage();
224         assertEquals("a[1.0, 2.0]", result);
225 
226         // double[]
227         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", new double[] { 1, 2 } }).getMessage();
228         assertEquals("a[1.0, 2.0]", result);
229 
230     }
231 
232     @Test
233     public void testMultiDimensionalArrayValues() {
234         Integer[][] multiIntegerA = new Integer[][] { ia0, ia1 };
235         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", multiIntegerA }).getMessage();
236         assertEquals("a[[1, 2, 3], [10, 20, 30]]", result);
237 
238         int[][] multiIntA = new int[][] { { 1, 2 }, { 10, 20 } };
239         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", multiIntA }).getMessage();
240         assertEquals("a[[1, 2], [10, 20]]", result);
241 
242         float[][] multiFloatA = new float[][] { { 1, 2 }, { 10, 20 } };
243         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", multiFloatA }).getMessage();
244         assertEquals("a[[1.0, 2.0], [10.0, 20.0]]", result);
245 
246         Object[][] multiOA = new Object[][] { ia0, ia1 };
247         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", multiOA }).getMessage();
248         assertEquals("a[[1, 2, 3], [10, 20, 30]]", result);
249 
250         Object[][][] _3DOA = new Object[][][] { multiOA, multiOA };
251         result = MessageFormatter.arrayFormat("{}{}", new Object[] { "a", _3DOA }).getMessage();
252         assertEquals("a[[[1, 2, 3], [10, 20, 30]], [[1, 2, 3], [10, 20, 30]]]", result);
253     }
254 
255     @Test
256     public void testCyclicArrays() {
257         {
258             Object[] cyclicA = new Object[1];
259             cyclicA[0] = cyclicA;
260             assertEquals("[[...]]", MessageFormatter.arrayFormat("{}", cyclicA).getMessage());
261         }
262         {
263             Object[] a = new Object[2];
264             a[0] = i1;
265             Object[] c = new Object[] { i3, a };
266             Object[] b = new Object[] { i2, c };
267             a[1] = b;
268             assertEquals("1[2, [3, [1, [...]]]]", MessageFormatter.arrayFormat("{}{}", a).getMessage());
269         }
270     }
271 
272     @Test
273     public void testArrayThrowable() {
274         FormattingTuple ft;
275         Throwable t = new Throwable();
276         Object[] ia = new Object[] { i1, i2, i3, t };
277         Object[] iaWitness = new Object[] { i1, i2, i3 };
278 
279         ft = MessageFormatter.arrayFormat("Value {} is smaller than {} and {}.", ia);
280         assertEquals("Value 1 is smaller than 2 and 3.", ft.getMessage());
281         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
282         assertEquals(t, ft.getThrowable());
283 
284         ft = MessageFormatter.arrayFormat("{}{}{}", ia);
285         assertEquals("123", ft.getMessage());
286         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
287         assertEquals(t, ft.getThrowable());
288 
289         ft = MessageFormatter.arrayFormat("Value {} is smaller than {}.", ia);
290         assertEquals("Value 1 is smaller than 2.", ft.getMessage());
291         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
292         assertEquals(t, ft.getThrowable());
293 
294         ft = MessageFormatter.arrayFormat("Value {} is smaller than {}", ia);
295         assertEquals("Value 1 is smaller than 2", ft.getMessage());
296         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
297         assertEquals(t, ft.getThrowable());
298 
299         ft = MessageFormatter.arrayFormat("Val={}, {, Val={}", ia);
300         assertEquals("Val=1, {, Val=2", ft.getMessage());
301         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
302         assertEquals(t, ft.getThrowable());
303 
304         ft = MessageFormatter.arrayFormat("Val={}, \\{, Val={}", ia);
305         assertEquals("Val=1, \\{, Val=2", ft.getMessage());
306         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
307         assertEquals(t, ft.getThrowable());
308 
309         ft = MessageFormatter.arrayFormat("Val1={}, Val2={", ia);
310         assertEquals("Val1=1, Val2={", ft.getMessage());
311         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
312         assertEquals(t, ft.getThrowable());
313 
314         ft = MessageFormatter.arrayFormat("Value {} is smaller than {} and {}.", ia);
315         assertEquals("Value 1 is smaller than 2 and 3.", ft.getMessage());
316         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
317         assertEquals(t, ft.getThrowable());
318 
319         ft = MessageFormatter.arrayFormat("{}{}{}{}", ia);
320         assertEquals("123{}", ft.getMessage());
321         assertTrue(Arrays.equals(iaWitness, ft.getArgArray()));
322         assertEquals(t, ft.getThrowable());
323 
324         ft = MessageFormatter.arrayFormat("1={}", new Object[] { i1 }, t);
325         assertEquals("1=1", ft.getMessage());
326         assertTrue(Arrays.equals(new Object[] { i1 }, ft.getArgArray()));
327         assertEquals(t, ft.getThrowable());
328 
329     }
330 }