1 /* ====================================================================
2 * License:
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * 3. The end-user documentation included with the redistribution,
17 * if any, must include the following acknowledgment:
18 * "This product includes software developed by
19 * Robert Half International (http://www.rhi.com/)."
20 * Alternately, this acknowledgment may appear in the software itself,
21 * if and wherever such third-party acknowledgments normally appear.
22 *
23 * 4. The names "Parc", "RHI", and "Robert Half International" must
24 * not be used to endorse or promote products derived from this
25 * software without prior written permission. For written
26 * permission, please contact pete.mckinstry@rhi.com.
27 *
28 * 5. Products derived from this software may not be called "PARC",
29 * nor may "PARC" appear in their name, without prior written
30 * permission of Robert Half International.
31 *
32 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
33 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
34 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
35 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
36 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
37 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
38 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
39 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
40 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
41 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
42 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43 * SUCH DAMAGE.
44 * ====================================================================
45 *
46 */
47 package com.rhi.architecture.logging;
48
49 import com.rhi.architecture.resource.InitializationException;
50
51 import java.util.Properties;
52
53 /***
54 * TestLogger
55 *
56 * @author Pete McKinstry
57 * @copyright 2002, Robert Half Int'l., Inc. All rights reserved.
58 *
59 * @since 1.2
60 */
61 public class TestLogger extends Logger {
62
63 private String name = null;
64
65 /***
66 * Constructor for TestLogger.
67 */
68 public TestLogger() {
69 super();
70 this.name = "default";
71 }
72
73 /***
74 * Constructor for TestLogger.
75 * @param name
76 */
77 public TestLogger(String name) {
78 super();
79 this.name = name;
80 }
81
82 /***
83 * Perform whatever initialization is required of the resource.
84 * @param p
85 * @throws InitializationException
86 * @since 1.1
87 */
88 public void init(Properties p) throws InitializationException {
89 // no-op
90 }
91
92 /***
93 * Perform whatever cleanup is required of the underlying object..
94 *
95 * @since 1.1
96 */
97 public void close() {
98 // no-op
99 }
100
101 /***
102 * Log a message w/ a debug priority.
103 *
104 * @param message - log message
105 *
106 * @since 1.01
107 */
108 public void debug(String message) {
109 System.out.println("debug: " + message);
110 }
111
112 /***
113 * Log a message w/ a trace priority.
114 *
115 * @param message - log message
116 *
117 * @since 1.01
118 */
119 public void trace(String message) {
120 System.out.println("trace: " + message);
121 }
122
123 /***
124 * Log a message w/ an error priority. Errors are used for
125 * problems found during processing that are not fatal. Actual
126 * support for this priority is log implementation specific,
127 * but should be available in most packages. (e.g. Log4J,
128 * JDK1.4)
129 *
130 * @param message - log message
131 *
132 * @since 1.0
133 */
134 public void error(String message) {
135 System.err.println("error: " + message);
136 }
137
138 /***
139 * Log a message w/ an error priority. Errors are used for
140 * problems found during processing that are not fatal. Actual
141 * support for this priority is log implementation specific,
142 * but should be available in most packages. (e.g. Log4J,
143 * JDK1.4)
144 *
145 * @param message - log message
146 * @param t
147 * @since 1.0
148 */
149 public void error(String message, Throwable t) {
150 System.err.println("error: " + message + t.toString());
151 }
152
153 /***
154 * Log a message w/ a fatal priority. Fatal messages are
155 * usually not recoverable & will precede an application
156 * shutdown. Actual support for this priority is log
157 * implementation specific, but should be available in
158 * most packages. (e.g. Log4J, JDK1.4)
159 *
160 * @param message - log message
161 *
162 * @since 1.0
163 */
164 public void fatal(String message) {
165 System.err.println("fatal: " + message);
166 }
167
168 /***
169 * Log a message w/ a fatal priority. Fatal messages are
170 * usually not recoverable & will precede an application
171 * shutdown. Actual support for this priority is log
172 * implementation specific, but should be available in
173 * most packages. (e.g. Log4J, JDK1.4)
174 *
175 * @param message - log message
176 * @param t
177 * @since 1.0
178 */
179 public void fatal(String message, Throwable t) {
180 System.err.println("fatal: " + message + t.toString());
181 }
182
183 /***
184 * Log a message w/ an informational priority. Informational
185 * messages will include things like operational statistics,
186 * which are nice to have, but don't signal an error of any
187 * kind in the application. The number of informational
188 * messages used in a process should be very low. Actual
189 * support for this priority is log implementation specific,
190 * but should be available in most packages. (e.g. Log4J,
191 * JDK1.4)
192 *
193 * @param message - log message
194 *
195 * @since 1.01
196 */
197 public void info(String message) {
198 System.out.println("info: " + message);
199 }
200
201 /***
202 * Log a message w/ a warning priority. Warnings are useful
203 * for messages that signal an error in the future if not
204 * corrected. (e.g. low disk space) or potential errors that
205 * may not be a problem depending on context that the logging
206 * component does not have. Actual support for this priority
207 * is log implementation specific, but should be available in
208 * most packages. (e.g. Log4J, JDK1.4)
209 *
210 * @param message - log message
211 *
212 * @since 1.01
213 */
214 public void warning(String message) {
215 System.err.println("warning: " + message);
216 }
217
218 /*** Check whether this category is enabled for the TRACE Level.
219 *
220 * @return boolean
221 *
222 * @since 1.0
223 */
224 public boolean isTraceEnabled() {
225 return true;
226 }
227
228 /*** Check whether this category is enabled for the DEBUG Level.
229 *
230 * @return boolean
231 *
232 * @since 1.0
233 */
234 public boolean isDebugEnabled() {
235 return true;
236 }
237
238 /*** Check whether this category is enabled for the INFO Level.
239 *
240 * @return boolean
241 *
242 * @since 1.0
243 */
244 public boolean isInfoEnabled() {
245 return true;
246 }
247
248 /*** Check whether this category is enabled for the WARNING Level.
249 *
250 * @return boolean
251 *
252 * @since 1.0
253 */
254 public boolean isWarningEnabled() {
255 return true;
256 }
257
258 }
This page was automatically generated by Maven