Skip to content

Commit d51e505

Browse files
magicwerkmagicwerk
committed
Add tests
1 parent d9b7fa6 commit d51e505

File tree

1 file changed

+210
-144
lines changed

1 file changed

+210
-144
lines changed

‎log4j-api-test/src/test/java/org/apache/logging/log4j/message/ParameterFormatterTest.java‎

Lines changed: 210 additions & 144 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323
import java.util.Collections;
2424
import java.util.List;
2525
import java.util.stream.Collectors;
26+
2627
import org.apache.logging.log4j.Level;
2728
import org.apache.logging.log4j.message.ParameterFormatter.MessagePatternAnalysis;
2829
import org.apache.logging.log4j.status.StatusData;
@@ -39,148 +40,213 @@
3940
@UsingStatusListener
4041
class ParameterFormatterTest {
4142

42-
final ListStatusListener statusListener;
43-
44-
ParameterFormatterTest(ListStatusListener statusListener) {
45-
this.statusListener = statusListener;
46-
}
47-
48-
@ParameterizedTest
49-
@CsvSource({
50-
"0,,false,",
51-
"0,,false,aaa",
52-
"0,,true,\\{}",
53-
"1,0,false,{}",
54-
"1,0,true,{}\\{}",
55-
"1,2,true,\\\\{}",
56-
"2,8:10,true,foo \\{} {}{}",
57-
"2,8:10,true,foo {\\} {}{}",
58-
"2,0:2,false,{}{}",
59-
"3,0:2:4,false,{}{}{}",
60-
"4,0:2:4:8,false,{}{}{}aa{}",
61-
"4,0:2:4:10,false,{}{}{}a{]b{}",
62-
"5,0:2:4:7:10,false,{}{}{}a{}b{}"
63-
})
64-
void test_pattern_analysis(
65-
final int placeholderCount,
66-
final String placeholderCharIndicesString,
67-
final boolean escapedPlaceholderFound,
68-
final String pattern) {
69-
MessagePatternAnalysis analysis = ParameterFormatter.analyzePattern(pattern, placeholderCount);
70-
assertThat(analysis.placeholderCount).isEqualTo(placeholderCount);
71-
if (placeholderCount > 0) {
72-
final int[] placeholderCharIndices = Arrays.stream(placeholderCharIndicesString.split(":"))
73-
.mapToInt(Integer::parseInt)
74-
.toArray();
75-
assertThat(analysis.placeholderCharIndices).startsWith(placeholderCharIndices);
76-
assertThat(analysis.escapedCharFound).isEqualTo(escapedPlaceholderFound);
77-
}
78-
}
79-
80-
@ParameterizedTest
81-
@CsvSource({"2,pan {} {},a,pan a {}", "3,pan {}{}{},a b,pan ab{}", "1,pan {},a b c,pan a"})
82-
void format_should_warn_on_insufficient_args(
83-
final int placeholderCount, final String pattern, final String argsStr, final String expectedMessage) {
84-
final String[] args = argsStr.split(" ");
85-
final int argCount = args.length;
86-
87-
String actualMessage = ParameterFormatter.format(pattern, args, argCount);
88-
assertThat(actualMessage).isEqualTo(expectedMessage);
89-
final List<StatusData> statusDataList = statusListener.getStatusData().collect(Collectors.toList());
90-
assertThat(statusDataList).hasSize(1);
91-
final StatusData statusData = statusDataList.get(0);
92-
assertThat(statusData.getLevel()).isEqualTo(Level.WARN);
93-
assertThat(statusData.getMessage().getFormattedMessage())
94-
.isEqualTo(
95-
"found %d argument placeholders, but provided %d for pattern `%s`",
96-
placeholderCount, argCount, pattern);
97-
}
98-
99-
@ParameterizedTest
100-
@MethodSource("messageFormattingTestCases")
101-
void format_should_work(
102-
final String pattern, final Object[] args, final int argCount, final String expectedFormattedMessage) {
103-
final String actualFormattedMessage = ParameterFormatter.format(pattern, args, argCount);
104-
assertThat(actualFormattedMessage).isEqualTo(expectedFormattedMessage);
105-
}
106-
107-
static Object[][] messageFormattingTestCases() {
108-
return new Object[][] {
109-
new Object[] {"Test message {}{} {}", new Object[] {"a", "b", "c"}, 3, "Test message ab c"},
110-
new Object[] {
111-
"Test message {} {} {} {} {} {}",
112-
new Object[] {"a", null, "c", null, null, null},
113-
6,
114-
"Test message a null c null null null"
115-
},
116-
new Object[] {
117-
"Test message {}{} {}",
118-
new Object[] {"a", "b", "c", "unnecessary", "superfluous"},
119-
5,
120-
"Test message ab c"
121-
},
122-
new Object[] {"Test message \\{}{} {}", new Object[] {"a", "b", "c"}, 3, "Test message {}a b"},
123-
new Object[] {"Test message {}{} {}\\", new Object[] {"a", "b", "c"}, 3, "Test message ab c\\"},
124-
new Object[] {"Test message {}{} {}\\\\", new Object[] {"a", "b", "c"}, 3, "Test message ab c\\"},
125-
new Object[] {"Test message \\\\{}{} {}", new Object[] {"a", "b", "c"}, 3, "Test message \\ab c"},
126-
new Object[] {"Test message {}{} {}", new Object[] {"a", "b", "c"}, 3, "Test message ab c"},
127-
new Object[] {
128-
"Test message {} {} {} {} {} {}",
129-
new Object[] {"a", null, "c", null, null, null},
130-
6,
131-
"Test message a null c null null null"
132-
},
133-
new Object[] {
134-
"Test message {}{} {}",
135-
new Object[] {"a", "b", "c", "unnecessary", "superfluous"},
136-
5,
137-
"Test message ab c"
138-
},
139-
new Object[] {"Test message \\{}{} {}", new Object[] {"a", "b", "c"}, 3, "Test message {}a b"},
140-
new Object[] {"Test message {}{} {}\\", new Object[] {"a", "b", "c"}, 3, "Test message ab c\\"},
141-
new Object[] {"Test message {}{} {}\\\\", new Object[] {"a", "b", "c"}, 3, "Test message ab c\\"},
142-
new Object[] {"Test message \\\\{}{} {}", new Object[] {"a", "b", "c"}, 3, "Test message \\ab c"},
143-
new Object[] {"foo \\\\\\{} {}", new Object[] {"bar"}, 1, "foo \\{} bar"},
144-
new Object[] {"missing arg {} {}", new Object[] {1, 2}, 1, "missing arg 1 {}"},
145-
new Object[] {"foo {\\} {}", new Object[] {"bar"}, 1, "foo {\\} bar"}
146-
};
147-
}
148-
149-
@Test
150-
void testDeepToString() {
151-
final List<Object> list = new ArrayList<>();
152-
list.add(1);
153-
// noinspection CollectionAddedToSelf
154-
list.add(list);
155-
list.add(2);
156-
final String actual = ParameterFormatter.deepToString(list);
157-
final String expected = "[1, [..." + ParameterFormatter.identityToString(list) + "...], 2]";
158-
assertThat(actual).isEqualTo(expected);
159-
}
160-
161-
@Test
162-
void testDeepToStringUsingNonRecursiveButConsequentObjects() {
163-
final List<Object> list = new ArrayList<>();
164-
final Object item = Collections.singletonList(0);
165-
list.add(1);
166-
list.add(item);
167-
list.add(2);
168-
list.add(item);
169-
list.add(3);
170-
final String actual = ParameterFormatter.deepToString(list);
171-
final String expected = "[1, [0], 2, [0], 3]";
172-
assertThat(actual).isEqualTo(expected);
173-
}
174-
175-
@Test
176-
void testIdentityToString() {
177-
final List<Object> list = new ArrayList<>();
178-
list.add(1);
179-
// noinspection CollectionAddedToSelf
180-
list.add(list);
181-
list.add(2);
182-
final String actual = ParameterFormatter.identityToString(list);
183-
final String expected = list.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(list));
184-
assertThat(actual).isEqualTo(expected);
185-
}
43+
final ListStatusListener statusListener;
44+
45+
ParameterFormatterTest(ListStatusListener statusListener) {
46+
this.statusListener = statusListener;
47+
}
48+
49+
@ParameterizedTest
50+
@CsvSource({
51+
"0,,false,",
52+
"0,,false,aaa",
53+
"0,,true,\\{}",
54+
"1,0,false,{}",
55+
"1,0,true,{}\\{}",
56+
"1,2,true,\\\\{}",
57+
"2,8:10,true,foo \\{} {}{}",
58+
"2,8:10,true,foo {\\} {}{}",
59+
"2,0:2,false,{}{}",
60+
"3,0:2:4,false,{}{}{}",
61+
"4,0:2:4:8,false,{}{}{}aa{}",
62+
"4,0:2:4:10,false,{}{}{}a{]b{}",
63+
"5,0:2:4:7:10,false,{}{}{}a{}b{}"
64+
})
65+
void test_pattern_analysis(
66+
final int placeholderCount,
67+
final String placeholderCharIndicesString,
68+
final boolean escapedPlaceholderFound,
69+
final String pattern) {
70+
MessagePatternAnalysis analysis = ParameterFormatter.analyzePattern(pattern, placeholderCount);
71+
assertThat(analysis.placeholderCount).isEqualTo(placeholderCount);
72+
if (placeholderCount > 0) {
73+
final int[] placeholderCharIndices = Arrays.stream(placeholderCharIndicesString.split(":"))
74+
.mapToInt(Integer::parseInt)
75+
.toArray();
76+
assertThat(analysis.placeholderCharIndices).startsWith(placeholderCharIndices);
77+
assertThat(analysis.escapedCharFound).isEqualTo(escapedPlaceholderFound);
78+
}
79+
}
80+
81+
@ParameterizedTest
82+
@CsvSource({ "2,pan {} {},a,pan a {}", "3,pan {}{}{},a b,pan ab{}", "1,pan {},a b c,pan a" })
83+
void format_should_warn_on_insufficient_args(
84+
final int placeholderCount, final String pattern, final String argsStr, final String expectedMessage) {
85+
final String[] args = argsStr.split(" ");
86+
final int argCount = args.length;
87+
88+
String actualMessage = ParameterFormatter.format(pattern, args, argCount);
89+
assertThat(actualMessage).isEqualTo(expectedMessage);
90+
final List<StatusData> statusDataList = statusListener.getStatusData().collect(Collectors.toList());
91+
assertThat(statusDataList).hasSize(1);
92+
final StatusData statusData = statusDataList.get(0);
93+
assertThat(statusData.getLevel()).isEqualTo(Level.WARN);
94+
assertThat(statusData.getMessage().getFormattedMessage())
95+
.isEqualTo(
96+
"found %d argument placeholders, but provided %d for pattern `%s`",
97+
placeholderCount, argCount, pattern);
98+
}
99+
100+
@ParameterizedTest
101+
@MethodSource("messageFormattingTestCases")
102+
void format_should_work(
103+
final String pattern, final Object[] args, final int argCount, final String expectedFormattedMessage) {
104+
final String actualFormattedMessage = ParameterFormatter.format(pattern, args, argCount);
105+
assertThat(actualFormattedMessage).isEqualTo(expectedFormattedMessage);
106+
}
107+
108+
static Object[][] messageFormattingTestCases() {
109+
return new Object[][] {
110+
new Object[] { "Test message {}{} {}", new Object[] { "a", "b", "c" }, 3, "Test message ab c" },
111+
new Object[] {
112+
"Test message {} {} {} {} {} {}",
113+
new Object[] { "a", null, "c", null, null, null },
114+
6,
115+
"Test message a null c null null null"
116+
},
117+
new Object[] {
118+
"Test message {}{} {}",
119+
new Object[] { "a", "b", "c", "unnecessary", "superfluous" },
120+
5,
121+
"Test message ab c"
122+
},
123+
new Object[] { "Test message \\{}{} {}", new Object[] { "a", "b", "c" }, 3, "Test message {}a b" },
124+
new Object[] { "Test message {}{} {}\\", new Object[] { "a", "b", "c" }, 3, "Test message ab c\\" },
125+
new Object[] { "Test message {}{} {}\\\\", new Object[] { "a", "b", "c" }, 3, "Test message ab c\\" },
126+
new Object[] { "Test message \\\\{}{} {}", new Object[] { "a", "b", "c" }, 3, "Test message \\ab c" },
127+
new Object[] { "Test message {}{} {}", new Object[] { "a", "b", "c" }, 3, "Test message ab c" },
128+
new Object[] {
129+
"Test message {} {} {} {} {} {}",
130+
new Object[] { "a", null, "c", null, null, null },
131+
6,
132+
"Test message a null c null null null"
133+
},
134+
new Object[] {
135+
"Test message {}{} {}",
136+
new Object[] { "a", "b", "c", "unnecessary", "superfluous" },
137+
5,
138+
"Test message ab c"
139+
},
140+
new Object[] { "Test message \\{}{} {}", new Object[] { "a", "b", "c" }, 3, "Test message {}a b" },
141+
new Object[] { "Test message {}{} {}\\", new Object[] { "a", "b", "c" }, 3, "Test message ab c\\" },
142+
new Object[] { "Test message {}{} {}\\\\", new Object[] { "a", "b", "c" }, 3, "Test message ab c\\" },
143+
new Object[] { "Test message \\\\{}{} {}", new Object[] { "a", "b", "c" }, 3, "Test message \\ab c" },
144+
new Object[] { "foo \\\\\\{} {}", new Object[] { "bar" }, 1, "foo \\{} bar" },
145+
new Object[] { "missing arg {} {}", new Object[] { 1, 2 }, 1, "missing arg 1 {}" },
146+
new Object[] { "foo {\\} {}", new Object[] { "bar" }, 1, "foo {\\} bar" }
147+
};
148+
}
149+
150+
@Test
151+
void testDeepToString() {
152+
final List<Object> list = new ArrayList<>();
153+
list.add(1);
154+
// noinspection CollectionAddedToSelf
155+
list.add(list);
156+
list.add(2);
157+
final String actual = ParameterFormatter.deepToString(list);
158+
final String expected = "[1, [..." + ParameterFormatter.identityToString(list) + "...], 2]";
159+
assertThat(actual).isEqualTo(expected);
160+
}
161+
162+
@Test
163+
void testDeepToStringUsingNonRecursiveButConsequentObjects() {
164+
final List<Object> list = new ArrayList<>();
165+
final Object item = Collections.singletonList(0);
166+
list.add(1);
167+
list.add(item);
168+
list.add(2);
169+
list.add(item);
170+
list.add(3);
171+
final String actual = ParameterFormatter.deepToString(list);
172+
final String expected = "[1, [0], 2, [0], 3]";
173+
assertThat(actual).isEqualTo(expected);
174+
}
175+
176+
@Test
177+
void testIdentityToString() {
178+
final List<Object> list = new ArrayList<>();
179+
list.add(1);
180+
// noinspection CollectionAddedToSelf
181+
list.add(list);
182+
list.add(2);
183+
final String actual = ParameterFormatter.identityToString(list);
184+
final String expected = list.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(list));
185+
assertThat(actual).isEqualTo(expected);
186+
}
187+
188+
@Test
189+
void testDeepToStringArrayByte() {
190+
final byte[] array = new byte[] { 0, 1, 2, 3, 4 };
191+
final String actual = ParameterFormatter.deepToString(array);
192+
final String expected = "[0, 1, 2, 3, 4]";
193+
assertThat(actual).isEqualTo(expected);
194+
}
195+
196+
@Test
197+
void testDeepToStringArrayShort() {
198+
final short[] array = new short[] { 0, 1, 2, 3, 4 };
199+
final String actual = ParameterFormatter.deepToString(array);
200+
final String expected = "[0, 1, 2, 3, 4]";
201+
assertThat(actual).isEqualTo(expected);
202+
}
203+
204+
@Test
205+
void testDeepToStringArrayInt() {
206+
final int[] array = new int[] { 0, 1, 2, 3, 4 };
207+
final String actual = ParameterFormatter.deepToString(array);
208+
final String expected = "[0, 1, 2, 3, 4]";
209+
assertThat(actual).isEqualTo(expected);
210+
}
211+
212+
@Test
213+
void testDeepToStringArrayLong() {
214+
final long[] array = new long[] { 0, 1, 2, 3, 4 };
215+
final String actual = ParameterFormatter.deepToString(array);
216+
final String expected = "[0, 1, 2, 3, 4]";
217+
assertThat(actual).isEqualTo(expected);
218+
}
219+
220+
@Test
221+
void testDeepToStringArrayFloat() {
222+
final float[] array = new float[] { 0, 1, 2, 3, 4 };
223+
final String actual = ParameterFormatter.deepToString(array);
224+
final String expected = "[0.0, 1.0, 2.0, 3.0, 4.0]";
225+
assertThat(actual).isEqualTo(expected);
226+
}
227+
228+
@Test
229+
void testDeepToStringArrayDouble() {
230+
final double[] array = new double[] { 0, 1, 2, 3, 4 };
231+
final String actual = ParameterFormatter.deepToString(array);
232+
final String expected = "[0.0, 1.0, 2.0, 3.0, 4.0]";
233+
assertThat(actual).isEqualTo(expected);
234+
}
235+
236+
@Test
237+
void testDeepToStringArrayBoolean() {
238+
final boolean[] array = new boolean[] { false, true };
239+
final String actual = ParameterFormatter.deepToString(array);
240+
final String expected = "[false, true]";
241+
assertThat(actual).isEqualTo(expected);
242+
}
243+
244+
@Test
245+
void testDeepToStringArrayChar() {
246+
final char[] array = new char[] { 'a', 'b', 'c' };
247+
final String actual = ParameterFormatter.deepToString(array);
248+
final String expected = "[a, b, c]";
249+
assertThat(actual).isEqualTo(expected);
250+
}
251+
186252
}

0 commit comments

Comments
 (0)