1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.server.wifi;
18
19import static org.junit.Assert.assertEquals;
20
21import android.test.suitebuilder.annotation.SmallTest;
22
23import org.junit.Before;
24import org.junit.Test;
25
26/**
27 * Unit tests for {@link LogcatLog}.
28 */
29@SmallTest
30public class LogcatLogTest {
31    private static final String TAG = "LogcatLogTest";
32    private LogcatLog mLogger;
33
34    /** Initializes test fixture. */
35    @Before
36    public void setUp() {
37        mLogger = new LogcatLog(TAG);
38    }
39
40    /**
41     * Verifies that LogcatLog's LogMessage implementation correctly
42     * handles a format with no parameters.
43     *
44     * Note: In practice, we expect clients to use eC() and friends
45     * when the message is a literal. But we still want to make sure
46     * this functionality works.
47     */
48    @Test
49    public void logMessageWorksWithParameterlessFormat() {
50        WifiLog.LogMessage logMessage = mLogger.err("hello world");
51        logMessage.flush();
52        assertEquals("hello world", logMessage.toString());
53    }
54
55    /** Verifies that LogMessage works with an empty format. */
56    @Test
57    public void logMessageWorksWithEmptyFormat() {
58        WifiLog.LogMessage logMessage = mLogger.err("");
59        logMessage.flush();
60        assertEquals("", logMessage.toString());
61    }
62
63    /** Verifies that LogMessage works with a value-only format. */
64    @Test
65    public void logMessageWorksWithValueOnly() {
66        WifiLog.LogMessage logMessage = mLogger.err("%");
67        logMessage.c(1).flush();
68        assertEquals("1", logMessage.toString());
69    }
70
71    /**
72     * Verifies that LogMessage works when the placeholder is replaced
73     * by the placeholder character.
74     */
75    @Test
76    public void logMessageIsNotConfusedByPlaceholderInValue() {
77        WifiLog.LogMessage logMessage = mLogger.err("%");
78        logMessage.c('%').flush();
79        assertEquals("%", logMessage.toString());
80    }
81
82    /** Verifies that LogMessage works when a value is at the start of the format. */
83    @Test
84    public void logMessageWorksWithValueAtBegin() {
85        WifiLog.LogMessage logMessage = mLogger.err("%stuff");
86        logMessage.c(1).flush();
87        assertEquals("1stuff", logMessage.toString());
88    }
89
90    /** Verifies that LogMessage works when a value is in the middle of the format. */
91    @Test
92    public void logMessageWorksWithValueInMiddle() {
93        WifiLog.LogMessage logMessage = mLogger.err("s%uff");
94        logMessage.c(1).flush();
95        assertEquals("s1uff", logMessage.toString());
96    }
97
98    /** Verifies that LogMessage works when a value is at the end of the format. */
99    @Test
100    public void logMessageWorksWithValueAtEnd() {
101        WifiLog.LogMessage logMessage = mLogger.err("stuff%");
102        logMessage.c(1).flush();
103        assertEquals("stuff1", logMessage.toString());
104    }
105
106    /** Verifies that LogMessage works when a format has multiple values. */
107    @Test
108    public void logMessageWorksWithMultipleValues() {
109        WifiLog.LogMessage logMessage = mLogger.err("% %");
110        logMessage.c("hello").c("world").flush();
111        assertEquals("hello world", logMessage.toString());
112    }
113
114    /** Verifies that LogMessage works when a format has multiple values and literals. */
115    @Test
116    public void logMessageWorksWithMultipleValuesAndLiterals() {
117        WifiLog.LogMessage logMessage = mLogger.err("first:% second:%");
118        logMessage.c("hello").c("world").flush();
119        assertEquals("first:hello second:world", logMessage.toString());
120    }
121
122    /** Verifies that LogMessage works when a format has multiple adjacent values. */
123    @Test
124    public void logMessageWorksWithAdjacentValues() {
125        WifiLog.LogMessage logMessage = mLogger.err("%%");
126        logMessage.c("hello").c("world").flush();
127        assertEquals("helloworld", logMessage.toString());
128    }
129
130    /** Verifies that LogMessage silently ignores extraneous values. */
131    @Test
132    public void logMessageSilentlyIgnoresExtraneousValues() {
133        WifiLog.LogMessage logMessage = mLogger.err("%");
134        logMessage.c("hello world");
135        logMessage.c("more stuff");
136        logMessage.flush();
137        assertEquals("hello world", logMessage.toString());
138    }
139
140    /**
141     * Verifies that LogMessage silently ignores extraneous values,
142     * even with an empty format string.
143     */
144    @Test
145    public void logMessageSilentlyIgnoresExtraneousValuesEvenForEmptyFormat() {
146        WifiLog.LogMessage logMessage = mLogger.err("");
147        logMessage.c("hello world");
148        logMessage.c("more stuff");
149        logMessage.flush();
150        assertEquals("", logMessage.toString());
151    }
152
153    /**
154     * Verifies that LogMessage silently ignores extraneous values,
155     * even if the format string is all literals.
156     */
157    @Test
158    public void logMessageSilentlyIgnoresExtraneousValuesEvenForFormatWithoutPlaceholders() {
159        WifiLog.LogMessage logMessage = mLogger.err("literal format");
160        logMessage.c("hello world");
161        logMessage.c("more stuff");
162        logMessage.flush();
163        assertEquals("literal format", logMessage.toString());
164    }
165
166    /** Verifies that LogMessage copies an unused placeholder to output. */
167    @Test
168    public void logMessageCopiesUnusedPlaceholderToOutput() {
169        WifiLog.LogMessage logMessage = mLogger.err("%");
170        logMessage.flush();
171        assertEquals("%", logMessage.toString());
172    }
173
174    /** Verifies that LogMessage copies multiple unused placeholders to output. */
175    @Test
176    public void logMessageCopiesMultipleUnusedPlaceholdersToOutput() {
177        WifiLog.LogMessage logMessage = mLogger.err("%%%%%");
178        logMessage.flush();
179        assertEquals("%%%%%", logMessage.toString());
180    }
181
182    /**
183     * Verifies that LogMessage copies an unused placeholder to output,
184     * even if preceded by non-placeholders.
185     */
186    @Test
187    public void logMessageCopiesUnusedPlaceholderAtEndToOutput() {
188        WifiLog.LogMessage logMessage = mLogger.err("foo%");
189        logMessage.flush();
190        assertEquals("foo%", logMessage.toString());
191    }
192
193    /**
194     * Verifies that LogMessage copies an unused placeholder to output,
195     * even if followed by non-placeholders.
196     */
197    @Test
198    public void logMessageCopiesUnusedPlaceholderAtBeginToOutput() {
199        WifiLog.LogMessage logMessage = mLogger.err("%foo");
200        logMessage.flush();
201        assertEquals("%foo", logMessage.toString());
202    }
203
204    /**
205     * Verifies that LogMessage copies an unused placeholder to output,
206     * even if it is in the middle of non-placeholders.
207     */
208    @Test
209    public void logMessageCopiesUnusedPlaceholderInMiddleToOutput() {
210        WifiLog.LogMessage logMessage = mLogger.err("f%o");
211        logMessage.flush();
212        assertEquals("f%o", logMessage.toString());
213    }
214
215    /**
216     * Verifies that LogMessage copies multiple unused placeholders to output,
217     * even if they are embedded amongst non-placeholders.
218     */
219    @Test
220    public void logMessageCopiesUnusedPlaceholdersInMiddleToOutput() {
221        WifiLog.LogMessage logMessage = mLogger.err("f%o%o%d");
222        logMessage.flush();
223        assertEquals("f%o%o%d", logMessage.toString());
224    }
225
226    /**
227     * Verifies that LogMessage preserves meta-characters in format string.
228     *
229     * Note that we deliberately test only the meta-characters that we
230     * expect to find in log messages. (Newline might also be
231     * preserved, but clients shouldn't depend on that, as messages
232     * that have newlines make logs hard to read.)
233     */
234    @Test
235    public void logMessagePreservesMetaCharactersInFormat() {
236        WifiLog.LogMessage logMessage = mLogger.err("\\hello\tworld\\");
237        logMessage.flush();
238        assertEquals("\\hello\tworld\\", logMessage.toString());
239    }
240
241    /** Verifies that LogMessage propagates meta-characters in char values. */
242    @Test
243    public void logMessagePropagatesMetaCharactersInCharValues() {
244        WifiLog.LogMessage logMessage = mLogger.err("hello%big%world");
245        logMessage.c('\t').c('\\').flush();
246        assertEquals("hello\tbig\\world", logMessage.toString());
247    }
248
249    /** Verifies that LogMessage propagates meta-characters in String values. */
250    @Test
251    public void logMessagePropagatesMetaCharactersInStringValues() {
252        WifiLog.LogMessage logMessage = mLogger.err("%%world");
253        logMessage.c("hello\t").c("big\\").flush();
254        assertEquals("hello\tbig\\world", logMessage.toString());
255    }
256}
257