Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.nntp.NNTP |
0% |
0% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
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 |  |
     package org.apache.commons.net.nntp;
17 |  |
18 |  |
     import java.io.BufferedReader;
19 |  |
     import java.io.BufferedWriter;
20 |  |
     import java.io.IOException;
21 |  |
     import java.io.InputStreamReader;
22 |  |
     import java.io.OutputStreamWriter;
23 |  |
     import org.apache.commons.net.MalformedServerReplyException;
24 |  |
     import org.apache.commons.net.ProtocolCommandSupport;
25 |  |
     import org.apache.commons.net.ProtocolCommandListener;
26 |  |
     import org.apache.commons.net.SocketClient;
27 |  |
28 |  |
     /***
29 |  |
      * The NNTP class is not meant to be used by itself and is provided
30 |  |
      * only so that you may easily implement your own NNTP client if
31 |  |
      * you so desire.  If you have no need to perform your own implementation,
32 |  |
      * you should use {@link org.apache.commons.net.nntp.NNTPClient}.
33 |  |
      * The NNTP class is made public to provide access to various NNTP constants
34 |  |
      * and to make it easier for adventurous programmers (or those with special
35 |  |
      * needs) to interact with the NNTP protocol and implement their own clients.
36 |  |
      * A set of methods with names corresponding to the NNTP command names are
37 |  |
      * provided to facilitate this interaction.
38 |  |
      * <p>
39 |  |
      * You should keep in mind that the NNTP server may choose to prematurely
40 |  |
      * close a connection if the client has been idle for longer than a
41 |  |
      * given time period or if the server is being shutdown by the operator or
42 |  |
      * some other reason.  The NNTP class will detect a
43 |  |
      * premature NNTP server connection closing when it receives a
44 |  |
      * {@link org.apache.commons.net.nntp.NNTPReply#SERVICE_DISCONTINUED NNTPReply.SERVICE_DISCONTINUED }
45 |  |
      *  response to a command.
46 |  |
      * When that occurs, the NNTP class method encountering that reply will throw
47 |  |
      * an {@link org.apache.commons.net.nntp.NNTPConnectionClosedException}
48 |  |
      * .
49 |  |
      * <code>NNTPConectionClosedException</code>
50 |  |
      * is a subclass of <code> IOException </code> and therefore need not be
51 |  |
      * caught separately, but if you are going to catch it separately, its
52 |  |
      * catch block must appear before the more general <code> IOException </code>
53 |  |
      * catch block.  When you encounter an
54 |  |
      * {@link org.apache.commons.net.nntp.NNTPConnectionClosedException}
55 |  |
      * , you must disconnect the connection with
56 |  |
      * {@link #disconnect  disconnect() } to properly clean up the
57 |  |
      * system resources used by NNTP.  Before disconnecting, you may check the
58 |  |
      * last reply code and text with
59 |  |
      * {@link #getReplyCode  getReplyCode } and
60 |  |
      * {@link #getReplyString  getReplyString }.
61 |  |
      * <p>
62 |  |
      * Rather than list it separately for each method, we mention here that
63 |  |
      * every method communicating with the server and throwing an IOException
64 |  |
      * can also throw a
65 |  |
      * {@link org.apache.commons.net.MalformedServerReplyException}
66 |  |
      * , which is a subclass
67 |  |
      * of IOException.  A MalformedServerReplyException will be thrown when
68 |  |
      * the reply received from the server deviates enough from the protocol
69 |  |
      * specification that it cannot be interpreted in a useful manner despite
70 |  |
      * attempts to be as lenient as possible.
71 |  |
      * <p>
72 |  |
      * <p>
73 |  |
      * @author Daniel F. Savarese
74 |  |
      * @author Rory Winston
75 |  |
      * @author Ted Wise
76 |  |
      * @see NNTPClient
77 |  |
      * @see NNTPConnectionClosedException
78 |  |
      * @see org.apache.commons.net.MalformedServerReplyException
79 |  |
      ***/
80 |  |
81 |  |
     public class NNTP extends SocketClient
82 |  |
     {
83 |  |
         /*** The default NNTP port.  Its value is 119 according to RFC 977. ***/
84 |  |
         public static final int DEFAULT_PORT = 119;
85 |  |
86 |  |
         // We have to ensure that the protocol communication is in ASCII
87 |  |
         // but we use ISO-8859-1 just in case 8-bit characters cross
88 |  |
         // the wire.
89 |  |
         private static final String __DEFAULT_ENCODING = "ISO-8859-1";
90 |  |
91 |  |
         private StringBuffer __commandBuffer;
92 |  |
93 |  |
         boolean _isAllowedToPost;
94 |  |
         int _replyCode;
95 |  |
         String _replyString;
96 |  |
97 |  |
         /**
98 |  |
          * Wraps {@link SocketClient#_input_}
99 |  |
          * to communicate with server.  Initialized by {@link #_connectAction_}.
100 |  |
          * All server reads should be done through this variable.
101 |  |
          */
102 |  |
         protected BufferedReader _reader_;
103 |  |
104 |  |
         /**
105 |  |
          * Wraps {@link SocketClient#_output_}
106 |  |
          * to communicate with server.  Initialized by {@link #_connectAction_}.
107 |  |
          * All server reads should be done through this variable.
108 |  |
          */
109 |  |
         protected BufferedWriter _writer_;
110 |  |
111 |  |
         /***
112 |  |
          * A ProtocolCommandSupport object used to manage the registering of
113 |  |
          * ProtocolCommandListeners and te firing of ProtocolCommandEvents.
114 |  |
          ***/
115 |  |
         protected ProtocolCommandSupport _commandSupport_;
116 |  |
117 |  |
         /***
118 |  |
          * The default NNTP constructor.  Sets the default port to
119 |  |
          * <code>DEFAULT_PORT</code> and initializes internal data structures
120 |  |
          * for saving NNTP reply information.
121 |  |
          ***/
122 |  |
         public NNTP()
123 | 0 |
         {
124 | 0 |
             setDefaultPort(DEFAULT_PORT);
125 | 0 |
             __commandBuffer = new StringBuffer();
126 | 0 |
             _replyString = null;
127 | 0 |
             _reader_ = null;
128 | 0 |
             _writer_ = null;
129 | 0 |
             _isAllowedToPost = false;
130 | 0 |
             _commandSupport_ = new ProtocolCommandSupport(this);
131 | 0 |
         }
132 |  |
133 |  |
         private void __getReply() throws IOException
134 |  |
         {
135 | 0 |
             _replyString = _reader_.readLine();
136 |  |
137 | 0 |
             if (_replyString == null)
138 | 0 |
                 throw new NNTPConnectionClosedException(
139 |  |
                     "Connection closed without indication.");
140 |  |
141 |  |
             // In case we run into an anomaly we don't want fatal index exceptions
142 |  |
             // to be thrown.
143 | 0 |
             if (_replyString.length() < 3)
144 | 0 |
                 throw new MalformedServerReplyException(
145 |  |
                     "Truncated server reply: " + _replyString);
146 |  |
             try
147 |  |
             {
148 | 0 |
                 _replyCode = Integer.parseInt(_replyString.substring(0, 3));
149 |  |
             }
150 | 0 |
             catch (NumberFormatException e)
151 |  |
             {
152 | 0 |
                 throw new MalformedServerReplyException(
153 |  |
                     "Could not parse response code.\nServer Reply: " + _replyString);
154 | 0 |
             }
155 |  |
156 | 0 |
             if (_commandSupport_.getListenerCount() > 0)
157 | 0 |
                 _commandSupport_.fireReplyReceived(_replyCode, _replyString +
158 |  |
                                                    SocketClient.NETASCII_EOL);
159 |  |
160 | 0 |
             if (_replyCode == NNTPReply.SERVICE_DISCONTINUED)
161 | 0 |
                 throw new NNTPConnectionClosedException(
162 |  |
                     "NNTP response 400 received.  Server closed connection.");
163 | 0 |
         }
164 |  |
165 |  |
         /***
166 |  |
          * Initiates control connections and gets initial reply, determining
167 |  |
          * if the client is allowed to post to the server.  Initializes
168 |  |
          * {@link #_reader_} and {@link #_writer_} to wrap
169 |  |
          * {@link SocketClient#_input_} and {@link SocketClient#_output_}.
170 |  |
          ***/
171 |  |
         protected void _connectAction_() throws IOException
172 |  |
         {
173 | 0 |
             super._connectAction_();
174 | 0 |
             _reader_ =
175 |  |
                 new BufferedReader(class="keyword">new InputStreamReader(_input_,
176 |  |
                                                          __DEFAULT_ENCODING));
177 | 0 |
             _writer_ =
178 |  |
                 new BufferedWriter(class="keyword">new OutputStreamWriter(_output_,
179 |  |
                                                           __DEFAULT_ENCODING));
180 | 0 |
             __getReply();
181 |  |
182 | 0 |
             _isAllowedToPost = (_replyCode == NNTPReply.SERVER_READY_POSTING_ALLOWED);
183 | 0 |
         }
184 |  |
185 |  |
         /***
186 |  |
          * Adds a ProtocolCommandListener.  Delegates this task to
187 |  |
          * {@link #_commandSupport_  _commandSupport_ }.
188 |  |
          * <p>
189 |  |
          * @param listener  The ProtocolCommandListener to add.
190 |  |
          ***/
191 |  |
         public void addProtocolCommandListener(ProtocolCommandListener listener)
192 |  |
         {
193 | 0 |
             _commandSupport_.addProtocolCommandListener(listener);
194 | 0 |
         }
195 |  |
196 |  |
         /***
197 |  |
          * Removes a ProtocolCommandListener.  Delegates this task to
198 |  |
          * {@link #_commandSupport_  _commandSupport_ }.
199 |  |
          * <p>
200 |  |
          * @param listener  The ProtocolCommandListener to remove.
201 |  |
          ***/
202 |  |
         public void removeProtocolCommandListener(ProtocolCommandListener listener)
203 |  |
         {
204 | 0 |
             _commandSupport_.removeProtocolCommandListener(listener);
205 | 0 |
         }
206 |  |
207 |  |
         /***
208 |  |
          * Closes the connection to the NNTP server and sets to null
209 |  |
          * some internal data so that the memory may be reclaimed by the
210 |  |
          * garbage collector.  The reply text and code information from the
211 |  |
          * last command is voided so that the memory it used may be reclaimed.
212 |  |
          * <p>
213 |  |
          * @exception IOException If an error occurs while disconnecting.
214 |  |
          ***/
215 |  |
         public void disconnect() throws IOException
216 |  |
         {
217 | 0 |
             super.disconnect();
218 | 0 |
             _reader_ = null;
219 | 0 |
             _writer_ = null;
220 | 0 |
             _replyString = null;
221 | 0 |
             _isAllowedToPost = false;
222 | 0 |
         }
223 |  |
224 |  |
225 |  |
         /***
226 |  |
          * Indicates whether or not the client is allowed to post articles to
227 |  |
          * the server it is currently connected to.
228 |  |
          * <p>
229 |  |
          * @return True if the client can post articles to the server, false
230 |  |
          *         otherwise.
231 |  |
          ***/
232 |  |
         public boolean isAllowedToPost()
233 |  |
         {
234 | 0 |
             return _isAllowedToPost;
235 |  |
         }
236 |  |
237 |  |
238 |  |
         /***
239 |  |
          * Sends an NNTP command to the server, waits for a reply and returns the
240 |  |
          * numerical response code.  After invocation, for more detailed
241 |  |
          * information, the actual reply text can be accessed by calling
242 |  |
          * {@link #getReplyString  getReplyString }.
243 |  |
          * <p>
244 |  |
          * @param command  The text representation of the  NNTP command to send.
245 |  |
          * @param args The arguments to the NNTP command.  If this parameter is
246 |  |
          *             set to null, then the command is sent with no argument.
247 |  |
          * @return The integer value of the NNTP reply code returned by the server
248 |  |
          *         in response to the command.
249 |  |
          * @exception NNTPConnectionClosedException
250 |  |
          *      If the NNTP server prematurely closes the connection as a result
251 |  |
          *      of the client being idle or some other reason causing the server
252 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
253 |  |
          *      as an IOException or independently as itself.
254 |  |
          * @exception IOException  If an I/O error occurs while either sending the
255 |  |
          *      command or receiving the server reply.
256 |  |
          ***/
257 |  |
         public int sendCommand(String command, String args) throws IOException
258 |  |
         {
259 |  |
             String message;
260 |  |
261 | 0 |
             __commandBuffer.setLength(0);
262 | 0 |
             __commandBuffer.append(command);
263 |  |
264 | 0 |
             if (args != null)
265 |  |
             {
266 | 0 |
                 __commandBuffer.append(' ');
267 | 0 |
                 __commandBuffer.append(args);
268 |  |
             }
269 | 0 |
             __commandBuffer.append(SocketClient.NETASCII_EOL);
270 |  |
271 | 0 |
             _writer_.write(message = __commandBuffer.toString());
272 | 0 |
             _writer_.flush();
273 |  |
274 | 0 |
             if (_commandSupport_.getListenerCount() > 0)
275 | 0 |
                 _commandSupport_.fireCommandSent(command, message);
276 |  |
277 | 0 |
             __getReply();
278 | 0 |
             return _replyCode;
279 |  |
         }
280 |  |
281 |  |
282 |  |
         /***
283 |  |
          * Sends an NNTP command to the server, waits for a reply and returns the
284 |  |
          * numerical response code.  After invocation, for more detailed
285 |  |
          * information, the actual reply text can be accessed by calling
286 |  |
          * {@link #getReplyString  getReplyString }.
287 |  |
          * <p>
288 |  |
          * @param command  The NNTPCommand constant corresponding to the NNTP command
289 |  |
          *                 to send.
290 |  |
          * @param args The arguments to the NNTP command.  If this parameter is
291 |  |
          *             set to null, then the command is sent with no argument.
292 |  |
          * @return The integer value of the NNTP reply code returned by the server
293 |  |
          *         in response to the command.
294 |  |
          *         in response to the command.
295 |  |
          * @exception NNTPConnectionClosedException
296 |  |
          *      If the NNTP server prematurely closes the connection as a result
297 |  |
          *      of the client being idle or some other reason causing the server
298 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
299 |  |
          *      as an IOException or independently as itself.
300 |  |
          * @exception IOException  If an I/O error occurs while either sending the
301 |  |
          *      command or receiving the server reply.
302 |  |
          ***/
303 |  |
         public int sendCommand(class="keyword">int command, String args) throws IOException
304 |  |
         {
305 | 0 |
             return sendCommand(NNTPCommand._commands[command], args);
306 |  |
         }
307 |  |
308 |  |
309 |  |
         /***
310 |  |
          * Sends an NNTP command with no arguments to the server, waits for a
311 |  |
          * reply and returns the numerical response code.  After invocation, for
312 |  |
          * more detailed information, the actual reply text can be accessed by
313 |  |
          * calling {@link #getReplyString  getReplyString }.
314 |  |
          * <p>
315 |  |
          * @param command  The text representation of the  NNTP command to send.
316 |  |
          * @return The integer value of the NNTP reply code returned by the server
317 |  |
          *         in response to the command.
318 |  |
          *         in response to the command.
319 |  |
          * @exception NNTPConnectionClosedException
320 |  |
          *      If the NNTP server prematurely closes the connection as a result
321 |  |
          *      of the client being idle or some other reason causing the server
322 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
323 |  |
          *      as an IOException or independently as itself.
324 |  |
          * @exception IOException  If an I/O error occurs while either sending the
325 |  |
          *      command or receiving the server reply.
326 |  |
          ***/
327 |  |
         public int sendCommand(String command) throws IOException
328 |  |
         {
329 | 0 |
             return sendCommand(command, null);
330 |  |
         }
331 |  |
332 |  |
333 |  |
         /***
334 |  |
          * Sends an NNTP command with no arguments to the server, waits for a
335 |  |
          * reply and returns the numerical response code.  After invocation, for
336 |  |
          * more detailed information, the actual reply text can be accessed by
337 |  |
          * calling {@link #getReplyString  getReplyString }.
338 |  |
          * <p>
339 |  |
          * @param command  The NNTPCommand constant corresponding to the NNTP command
340 |  |
          *                 to send.
341 |  |
          * @return The integer value of the NNTP reply code returned by the server
342 |  |
          *         in response to the command.
343 |  |
          *         in response to the command.
344 |  |
          * @exception NNTPConnectionClosedException
345 |  |
          *      If the NNTP server prematurely closes the connection as a result
346 |  |
          *      of the client being idle or some other reason causing the server
347 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
348 |  |
          *      as an IOException or independently as itself.
349 |  |
          * @exception IOException  If an I/O error occurs while either sending the
350 |  |
          *      command or receiving the server reply.
351 |  |
          ***/
352 |  |
         public int sendCommand(class="keyword">int command) throws IOException
353 |  |
         {
354 | 0 |
             return sendCommand(command, null);
355 |  |
         }
356 |  |
357 |  |
358 |  |
         /***
359 |  |
          * Returns the integer value of the reply code of the last NNTP reply.
360 |  |
          * You will usually only use this method after you connect to the
361 |  |
          * NNTP server to check that the connection was successful since
362 |  |
          * <code> connect </code> is of type void.
363 |  |
          * <p>
364 |  |
          * @return The integer value of the reply code of the last NNTP reply.
365 |  |
          ***/
366 |  |
         public int getReplyCode()
367 |  |
         {
368 | 0 |
             return _replyCode;
369 |  |
         }
370 |  |
371 |  |
         /***
372 |  |
          * Fetches a reply from the NNTP server and returns the integer reply
373 |  |
          * code.  After calling this method, the actual reply text can be accessed
374 |  |
          * from {@link #getReplyString  getReplyString }.  Only use this
375 |  |
          * method if you are implementing your own NNTP client or if you need to
376 |  |
          * fetch a secondary response from the NNTP server.
377 |  |
          * <p>
378 |  |
          * @return The integer value of the reply code of the fetched NNTP reply.
379 |  |
          *         in response to the command.
380 |  |
          * @exception NNTPConnectionClosedException
381 |  |
          *      If the NNTP server prematurely closes the connection as a result
382 |  |
          *      of the client being idle or some other reason causing the server
383 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
384 |  |
          *      as an IOException or independently as itself.
385 |  |
          * @exception IOException  If an I/O error occurs while
386 |  |
          *      receiving the server reply.
387 |  |
          ***/
388 |  |
         public int getReply() throws IOException
389 |  |
         {
390 | 0 |
             __getReply();
391 | 0 |
             return _replyCode;
392 |  |
         }
393 |  |
394 |  |
395 |  |
         /***
396 |  |
          * Returns the entire text of the last NNTP server response exactly
397 |  |
          * as it was received, not including the end of line marker.
398 |  |
          * <p>
399 |  |
          * @return The entire text from the last NNTP response as a String.
400 |  |
          ***/
401 |  |
         public String getReplyString()
402 |  |
         {
403 | 0 |
             return _replyString;
404 |  |
         }
405 |  |
406 |  |
407 |  |
         /***
408 |  |
          * A convenience method to send the NNTP ARTICLE command to the server,
409 |  |
          * receive the initial reply, and return the reply code.
410 |  |
          * <p>
411 |  |
          * @param messageId  The message identifier of the requested article,
412 |  |
          *                   including the encapsulating &lt and &gt characters.
413 |  |
          * @return The reply code received from the server.
414 |  |
          * @exception NNTPConnectionClosedException
415 |  |
          *      If the NNTP server prematurely closes the connection as a result
416 |  |
          *      of the client being idle or some other reason causing the server
417 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
418 |  |
          *      as an IOException or independently as itself.
419 |  |
          * @exception IOException  If an I/O error occurs while either sending the
420 |  |
          *      command or receiving the server reply.
421 |  |
          ***/
422 |  |
         public int article(String messageId) throws IOException
423 |  |
         {
424 | 0 |
             return sendCommand(NNTPCommand.ARTICLE, messageId);
425 |  |
         }
426 |  |
427 |  |
         /***
428 |  |
          * A convenience method to send the NNTP ARTICLE command to the server,
429 |  |
          * receive the initial reply, and return the reply code.
430 |  |
          * <p>
431 |  |
          * @param articleNumber The number of the article to request from the
432 |  |
          *                      currently selected newsgroup.
433 |  |
          * @return The reply code received from the server.
434 |  |
          * @exception NNTPConnectionClosedException
435 |  |
          *      If the NNTP server prematurely closes the connection as a result
436 |  |
          *      of the client being idle or some other reason causing the server
437 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
438 |  |
          *      as an IOException or independently as itself.
439 |  |
          * @exception IOException  If an I/O error occurs while either sending the
440 |  |
          *      command or receiving the server reply.
441 |  |
          ***/
442 |  |
         public int article(class="keyword">int articleNumber) throws IOException
443 |  |
         {
444 | 0 |
             return sendCommand(NNTPCommand.ARTICLE, Integer.toString(articleNumber));
445 |  |
         }
446 |  |
447 |  |
         /***
448 |  |
          * A convenience method to send the NNTP ARTICLE command to the server,
449 |  |
          * receive the initial reply, and return the reply code.
450 |  |
          * <p>
451 |  |
          * @return The reply code received from the server.
452 |  |
          * @exception NNTPConnectionClosedException
453 |  |
          *      If the NNTP server prematurely closes the connection as a result
454 |  |
          *      of the client being idle or some other reason causing the server
455 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
456 |  |
          *      as an IOException or independently as itself.
457 |  |
          * @exception IOException  If an I/O error occurs while either sending the
458 |  |
          *      command or receiving the server reply.
459 |  |
          ***/
460 |  |
         public int article() throws IOException
461 |  |
         {
462 | 0 |
             return sendCommand(NNTPCommand.ARTICLE);
463 |  |
         }
464 |  |
465 |  |
466 |  |
467 |  |
         /***
468 |  |
          * A convenience method to send the NNTP BODY command to the server,
469 |  |
          * receive the initial reply, and return the reply code.
470 |  |
          * <p>
471 |  |
          * @param messageId  The message identifier of the requested article,
472 |  |
          *                   including the encapsulating &lt and &gt characters.
473 |  |
          * @return The reply code received from the server.
474 |  |
          * @exception NNTPConnectionClosedException
475 |  |
          *      If the NNTP server prematurely closes the connection as a result
476 |  |
          *      of the client being idle or some other reason causing the server
477 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
478 |  |
          *      as an IOException or independently as itself.
479 |  |
          * @exception IOException  If an I/O error occurs while either sending the
480 |  |
          *      command or receiving the server reply.
481 |  |
          ***/
482 |  |
         public int body(String messageId) throws IOException
483 |  |
         {
484 | 0 |
             return sendCommand(NNTPCommand.BODY, messageId);
485 |  |
         }
486 |  |
487 |  |
         /***
488 |  |
          * A convenience method to send the NNTP BODY command to the server,
489 |  |
          * receive the initial reply, and return the reply code.
490 |  |
          * <p>
491 |  |
          * @param articleNumber The number of the article to request from the
492 |  |
          *                      currently selected newsgroup.
493 |  |
          * @return The reply code received from the server.
494 |  |
          * @exception NNTPConnectionClosedException
495 |  |
          *      If the NNTP server prematurely closes the connection as a result
496 |  |
          *      of the client being idle or some other reason causing the server
497 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
498 |  |
          *      as an IOException or independently as itself.
499 |  |
          * @exception IOException  If an I/O error occurs while either sending the
500 |  |
          *      command or receiving the server reply.
501 |  |
          ***/
502 |  |
         public int body(class="keyword">int articleNumber) throws IOException
503 |  |
         {
504 | 0 |
             return sendCommand(NNTPCommand.BODY, Integer.toString(articleNumber));
505 |  |
         }
506 |  |
507 |  |
         /***
508 |  |
          * A convenience method to send the NNTP BODY command to the server,
509 |  |
          * receive the initial reply, and return the reply code.
510 |  |
          * <p>
511 |  |
          * @return The reply code received from the server.
512 |  |
          * @exception NNTPConnectionClosedException
513 |  |
          *      If the NNTP server prematurely closes the connection as a result
514 |  |
          *      of the client being idle or some other reason causing the server
515 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
516 |  |
          *      as an IOException or independently as itself.
517 |  |
          * @exception IOException  If an I/O error occurs while either sending the
518 |  |
          *      command or receiving the server reply.
519 |  |
          ***/
520 |  |
         public int body() throws IOException
521 |  |
         {
522 | 0 |
             return sendCommand(NNTPCommand.BODY);
523 |  |
         }
524 |  |
525 |  |
526 |  |
527 |  |
         /***
528 |  |
          * A convenience method to send the NNTP HEAD command to the server,
529 |  |
          * receive the initial reply, and return the reply code.
530 |  |
          * <p>
531 |  |
          * @param messageId  The message identifier of the requested article,
532 |  |
          *                   including the encapsulating &lt and &gt characters.
533 |  |
          * @return The reply code received from the server.
534 |  |
          * @exception NNTPConnectionClosedException
535 |  |
          *      If the NNTP server prematurely closes the connection as a result
536 |  |
          *      of the client being idle or some other reason causing the server
537 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
538 |  |
          *      as an IOException or independently as itself.
539 |  |
          * @exception IOException  If an I/O error occurs while either sending the
540 |  |
          *      command or receiving the server reply.
541 |  |
          ***/
542 |  |
         public int head(String messageId) throws IOException
543 |  |
         {
544 | 0 |
             return sendCommand(NNTPCommand.HEAD, messageId);
545 |  |
         }
546 |  |
547 |  |
         /***
548 |  |
          * A convenience method to send the NNTP HEAD command to the server,
549 |  |
          * receive the initial reply, and return the reply code.
550 |  |
          * <p>
551 |  |
          * @param articleNumber The number of the article to request from the
552 |  |
          *                      currently selected newsgroup.
553 |  |
          * @return The reply code received from the server.
554 |  |
          * @exception NNTPConnectionClosedException
555 |  |
          *      If the NNTP server prematurely closes the connection as a result
556 |  |
          *      of the client being idle or some other reason causing the server
557 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
558 |  |
          *      as an IOException or independently as itself.
559 |  |
          * @exception IOException  If an I/O error occurs while either sending the
560 |  |
          *      command or receiving the server reply.
561 |  |
          ***/
562 |  |
         public int head(class="keyword">int articleNumber) throws IOException
563 |  |
         {
564 | 0 |
             return sendCommand(NNTPCommand.HEAD, Integer.toString(articleNumber));
565 |  |
         }
566 |  |
567 |  |
         /***
568 |  |
          * A convenience method to send the NNTP HEAD command to the server,
569 |  |
          * receive the initial reply, and return the reply code.
570 |  |
          * <p>
571 |  |
          * @return The reply code received from the server.
572 |  |
          * @exception NNTPConnectionClosedException
573 |  |
          *      If the NNTP server prematurely closes the connection as a result
574 |  |
          *      of the client being idle or some other reason causing the server
575 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
576 |  |
          *      as an IOException or independently as itself.
577 |  |
          * @exception IOException  If an I/O error occurs while either sending the
578 |  |
          *      command or receiving the server reply.
579 |  |
          ***/
580 |  |
         public int head() throws IOException
581 |  |
         {
582 | 0 |
             return sendCommand(NNTPCommand.HEAD);
583 |  |
         }
584 |  |
585 |  |
586 |  |
587 |  |
         /***
588 |  |
          * A convenience method to send the NNTP STAT command to the server,
589 |  |
          * receive the initial reply, and return the reply code.
590 |  |
          * <p>
591 |  |
          * @param messageId  The message identifier of the requested article,
592 |  |
          *                   including the encapsulating &lt and &gt characters.
593 |  |
          * @return The reply code received from the server.
594 |  |
          * @exception NNTPConnectionClosedException
595 |  |
          *      If the NNTP server prematurely closes the connection as a result
596 |  |
          *      of the client being idle or some other reason causing the server
597 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
598 |  |
          *      as an IOException or independently as itself.
599 |  |
          * @exception IOException  If an I/O error occurs while either sending the
600 |  |
          *      command or receiving the server reply.
601 |  |
          ***/
602 |  |
         public int stat(String messageId) throws IOException
603 |  |
         {
604 | 0 |
             return sendCommand(NNTPCommand.STAT, messageId);
605 |  |
         }
606 |  |
607 |  |
         /***
608 |  |
          * A convenience method to send the NNTP STAT command to the server,
609 |  |
          * receive the initial reply, and return the reply code.
610 |  |
          * <p>
611 |  |
          * @param articleNumber The number of the article to request from the
612 |  |
          *                      currently selected newsgroup.
613 |  |
          * @return The reply code received from the server.
614 |  |
          * @exception NNTPConnectionClosedException
615 |  |
          *      If the NNTP server prematurely closes the connection as a result
616 |  |
          *      of the client being idle or some other reason causing the server
617 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
618 |  |
          *      as an IOException or independently as itself.
619 |  |
          * @exception IOException  If an I/O error occurs while either sending the
620 |  |
          *      command or receiving the server reply.
621 |  |
          ***/
622 |  |
         public int stat(class="keyword">int articleNumber) throws IOException
623 |  |
         {
624 | 0 |
             return sendCommand(NNTPCommand.STAT, Integer.toString(articleNumber));
625 |  |
         }
626 |  |
627 |  |
         /***
628 |  |
          * A convenience method to send the NNTP STAT command to the server,
629 |  |
          * receive the initial reply, and return the reply code.
630 |  |
          * <p>
631 |  |
          * @return The reply code received from the server.
632 |  |
          * @exception NNTPConnectionClosedException
633 |  |
          *      If the NNTP server prematurely closes the connection as a result
634 |  |
          *      of the client being idle or some other reason causing the server
635 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
636 |  |
          *      as an IOException or independently as itself.
637 |  |
          * @exception IOException  If an I/O error occurs while either sending the
638 |  |
          *      command or receiving the server reply.
639 |  |
          ***/
640 |  |
         public int stat() throws IOException
641 |  |
         {
642 | 0 |
             return sendCommand(NNTPCommand.STAT);
643 |  |
         }
644 |  |
645 |  |
646 |  |
         /***
647 |  |
          * A convenience method to send the NNTP GROUP command to the server,
648 |  |
          * receive the reply, and return the reply code.
649 |  |
          * <p>
650 |  |
          * @param newsgroup  The name of the newsgroup to select.
651 |  |
          * @return The reply code received from the server.
652 |  |
          * @exception NNTPConnectionClosedException
653 |  |
          *      If the NNTP server prematurely closes the connection as a result
654 |  |
          *      of the client being idle or some other reason causing the server
655 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
656 |  |
          *      as an IOException or independently as itself.
657 |  |
          * @exception IOException  If an I/O error occurs while either sending the
658 |  |
          *      command or receiving the server reply.
659 |  |
          ***/
660 |  |
         public int group(String newsgroup) throws IOException
661 |  |
         {
662 | 0 |
             return sendCommand(NNTPCommand.GROUP, newsgroup);
663 |  |
         }
664 |  |
665 |  |
666 |  |
         /***
667 |  |
          * A convenience method to send the NNTP HELP command to the server,
668 |  |
          * receive the reply, and return the reply code.
669 |  |
          * <p>
670 |  |
          * @return The reply code received from the server.
671 |  |
          * @exception NNTPConnectionClosedException
672 |  |
          *      If the NNTP server prematurely closes the connection as a result
673 |  |
          *      of the client being idle or some other reason causing the server
674 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
675 |  |
          *      as an IOException or independently as itself.
676 |  |
          * @exception IOException  If an I/O error occurs while either sending the
677 |  |
          *      command or receiving the server reply.
678 |  |
          ***/
679 |  |
         public int help() throws IOException
680 |  |
         {
681 | 0 |
             return sendCommand(NNTPCommand.HELP);
682 |  |
         }
683 |  |
684 |  |
685 |  |
         /***
686 |  |
          * A convenience method to send the NNTP IHAVE command to the server,
687 |  |
          * receive the reply, and return the reply code.
688 |  |
          * <p>
689 |  |
          * @param messageId  The article identifier,
690 |  |
          *                   including the encapsulating &lt and &gt characters.
691 |  |
          * @return The reply code received from the server.
692 |  |
          * @exception NNTPConnectionClosedException
693 |  |
          *      If the NNTP server prematurely closes the connection as a result
694 |  |
          *      of the client being idle or some other reason causing the server
695 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
696 |  |
          *      as an IOException or independently as itself.
697 |  |
          * @exception IOException  If an I/O error occurs while either sending the
698 |  |
          *      command or receiving the server reply.
699 |  |
          ***/
700 |  |
         public int ihave(String messageId) throws IOException
701 |  |
         {
702 | 0 |
             return sendCommand(NNTPCommand.IHAVE, messageId);
703 |  |
         }
704 |  |
705 |  |
706 |  |
         /***
707 |  |
          * A convenience method to send the NNTP LAST command to the server,
708 |  |
          * receive the reply, and return the reply code.
709 |  |
          * <p>
710 |  |
          * @return The reply code received from the server.
711 |  |
          * @exception NNTPConnectionClosedException
712 |  |
          *      If the NNTP server prematurely closes the connection as a result
713 |  |
          *      of the client being idle or some other reason causing the server
714 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
715 |  |
          *      as an IOException or independently as itself.
716 |  |
          * @exception IOException  If an I/O error occurs while either sending the
717 |  |
          *      command or receiving the server reply.
718 |  |
          ***/
719 |  |
         public int last() throws IOException
720 |  |
         {
721 | 0 |
             return sendCommand(NNTPCommand.LAST);
722 |  |
         }
723 |  |
724 |  |
725 |  |
726 |  |
         /***
727 |  |
          * A convenience method to send the NNTP LIST command to the server,
728 |  |
          * receive the reply, and return the reply code.
729 |  |
          * <p>
730 |  |
          * @return The reply code received from the server.
731 |  |
          * @exception NNTPConnectionClosedException
732 |  |
          *      If the NNTP server prematurely closes the connection as a result
733 |  |
          *      of the client being idle or some other reason causing the server
734 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
735 |  |
          *      as an IOException or independently as itself.
736 |  |
          * @exception IOException  If an I/O error occurs while either sending the
737 |  |
          *      command or receiving the server reply.
738 |  |
          ***/
739 |  |
         public int list() throws IOException
740 |  |
         {
741 | 0 |
             return sendCommand(NNTPCommand.LIST);
742 |  |
         }
743 |  |
744 |  |
745 |  |
746 |  |
         /***
747 |  |
          * A convenience method to send the NNTP NEXT command to the server,
748 |  |
          * receive the reply, and return the reply code.
749 |  |
          * <p>
750 |  |
          * @return The reply code received from the server.
751 |  |
          * @exception NNTPConnectionClosedException
752 |  |
          *      If the NNTP server prematurely closes the connection as a result
753 |  |
          *      of the client being idle or some other reason causing the server
754 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
755 |  |
          *      as an IOException or independently as itself.
756 |  |
          * @exception IOException  If an I/O error occurs while either sending the
757 |  |
          *      command or receiving the server reply.
758 |  |
          ***/
759 |  |
         public int next() throws IOException
760 |  |
         {
761 | 0 |
             return sendCommand(NNTPCommand.NEXT);
762 |  |
         }
763 |  |
764 |  |
765 |  |
         /***
766 |  |
          * A convenience method to send the NNTP NEWGROUPS command to the server,
767 |  |
          * receive the reply, and return the reply code.
768 |  |
          * <p>
769 |  |
          * @param date The date after which to check for new groups.
770 |  |
          *             Date format is YYMMDD
771 |  |
          * @param time The time after which to check for new groups.
772 |  |
          *             Time format is HHMMSS using a 24-hour clock.
773 |  |
          * @param GMT  True if the time is in GMT, false if local server time.
774 |  |
          * @param distributions  Comma-separated distribution list to check for
775 |  |
          *            new groups. Set to null if no distributions.
776 |  |
          * @return The reply code received from the server.
777 |  |
          * @exception NNTPConnectionClosedException
778 |  |
          *      If the NNTP server prematurely closes the connection as a result
779 |  |
          *      of the client being idle or some other reason causing the server
780 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
781 |  |
          *      as an IOException or independently as itself.
782 |  |
          * @exception IOException  If an I/O error occurs while either sending the
783 |  |
          *      command or receiving the server reply.
784 |  |
          ***/
785 |  |
         public int newgroups(String date, String time, boolean GMT,
786 |  |
                              String distributions) throws IOException
787 |  |
         {
788 | 0 |
             StringBuffer buffer = new StringBuffer();
789 |  |
790 | 0 |
             buffer.append(date);
791 | 0 |
             buffer.append(' ');
792 | 0 |
             buffer.append(time);
793 |  |
794 | 0 |
             if (GMT)
795 |  |
             {
796 | 0 |
                 buffer.append(' ');
797 | 0 |
                 buffer.append("GMT");
798 |  |
             }
799 |  |
800 | 0 |
             if (distributions != null)
801 |  |
             {
802 | 0 |
                 buffer.append(" <");
803 | 0 |
                 buffer.append(distributions);
804 | 0 |
                 buffer.append('>');
805 |  |
             }
806 |  |
807 | 0 |
             return sendCommand(NNTPCommand.NEWGROUPS, buffer.toString());
808 |  |
         }
809 |  |
810 |  |
811 |  |
         /***
812 |  |
          * A convenience method to send the NNTP NEWGROUPS command to the server,
813 |  |
          * receive the reply, and return the reply code.
814 |  |
          * <p>
815 |  |
          * @param newsgroups A comma-separated list of newsgroups to check for new
816 |  |
          *             news.
817 |  |
          * @param date The date after which to check for new news.
818 |  |
          *             Date format is YYMMDD
819 |  |
          * @param time The time after which to check for new news.
820 |  |
          *             Time format is HHMMSS using a 24-hour clock.
821 |  |
          * @param GMT  True if the time is in GMT, false if local server time.
822 |  |
          * @param distributions  Comma-separated distribution list to check for
823 |  |
          *            new news. Set to null if no distributions.
824 |  |
          * @return The reply code received from the server.
825 |  |
          * @exception NNTPConnectionClosedException
826 |  |
          *      If the NNTP server prematurely closes the connection as a result
827 |  |
          *      of the client being idle or some other reason causing the server
828 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
829 |  |
          *      as an IOException or independently as itself.
830 |  |
          * @exception IOException  If an I/O error occurs while either sending the
831 |  |
          *      command or receiving the server reply.
832 |  |
          ***/
833 |  |
         public int newnews(String newsgroups, String date, String time, boolean GMT,
834 |  |
                            String distributions) throws IOException
835 |  |
         {
836 | 0 |
             StringBuffer buffer = new StringBuffer();
837 |  |
838 | 0 |
             buffer.append(newsgroups);
839 | 0 |
             buffer.append(' ');
840 | 0 |
             buffer.append(date);
841 | 0 |
             buffer.append(' ');
842 | 0 |
             buffer.append(time);
843 |  |
844 | 0 |
             if (GMT)
845 |  |
             {
846 | 0 |
                 buffer.append(' ');
847 | 0 |
                 buffer.append("GMT");
848 |  |
             }
849 |  |
850 | 0 |
             if (distributions != null)
851 |  |
             {
852 | 0 |
                 buffer.append(" <");
853 | 0 |
                 buffer.append(distributions);
854 | 0 |
                 buffer.append('>');
855 |  |
             }
856 |  |
857 | 0 |
             return sendCommand(NNTPCommand.NEWNEWS, buffer.toString());
858 |  |
         }
859 |  |
860 |  |
861 |  |
862 |  |
         /***
863 |  |
          * A convenience method to send the NNTP POST command to the server,
864 |  |
          * receive the reply, and return the reply code.
865 |  |
          * <p>
866 |  |
          * @return The reply code received from the server.
867 |  |
          * @exception NNTPConnectionClosedException
868 |  |
          *      If the NNTP server prematurely closes the connection as a result
869 |  |
          *      of the client being idle or some other reason causing the server
870 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
871 |  |
          *      as an IOException or independently as itself.
872 |  |
          * @exception IOException  If an I/O error occurs while either sending the
873 |  |
          *      command or receiving the server reply.
874 |  |
          ***/
875 |  |
         public int post() throws IOException
876 |  |
         {
877 | 0 |
             return sendCommand(NNTPCommand.POST);
878 |  |
         }
879 |  |
880 |  |
881 |  |
882 |  |
         /***
883 |  |
          * A convenience method to send the NNTP QUIT command to the server,
884 |  |
          * receive the reply, and return the reply code.
885 |  |
          * <p>
886 |  |
          * @return The reply code received from the server.
887 |  |
          * @exception NNTPConnectionClosedException
888 |  |
          *      If the NNTP server prematurely closes the connection as a result
889 |  |
          *      of the client being idle or some other reason causing the server
890 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
891 |  |
          *      as an IOException or independently as itself.
892 |  |
          * @exception IOException  If an I/O error occurs while either sending the
893 |  |
          *      command or receiving the server reply.
894 |  |
          ***/
895 |  |
         public int quit() throws IOException
896 |  |
         {
897 | 0 |
             return sendCommand(NNTPCommand.QUIT);
898 |  |
         }
899 |  |
900 |  |
         /***
901 |  |
          * A convenience method to send the AUTHINFO USER command to the server,
902 |  |
          *  receive the reply, and return the reply code. (See RFC 2980)
903 |  |
          * <p>
904 |  |
          * @param username A valid username.
905 |  |
          * @return The reply code received from the server. The server should
906 |  |
          *          return a 381 or 281 for this command.
907 |  |
          * @exception NNTPConnectionClosedException
908 |  |
          *      If the NNTP server prematurely closes the connection as a result
909 |  |
          *      of the client being idle or some other reason causing the server
910 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
911 |  |
          *      as an IOException or independently as itself.
912 |  |
          * @exception IOException  If an I/O error occurs while either sending the
913 |  |
          *      command or receiving the server reply.
914 |  |
          ***/
915 |  |
         public int authinfoUser(String username) throws IOException {
916 | 0 |
             String userParameter = "USER " + username;
917 | 0 |
             return sendCommand(NNTPCommand.AUTHINFO, userParameter);
918 |  |
         }
919 |  |
920 |  |
         /***
921 |  |
          * A convenience method to send the AUTHINFO PASS command to the server,
922 |  |
          * receive the reply, and return the reply code.  If this step is
923 |  |
          * required, it should immediately follow the AUTHINFO USER command
924 |  |
          * (See RFC 2980)
925 |  |
          * <p>
926 |  |
          * @param password a valid password.
927 |  |
          * @return The reply code received from the server. The server should
928 |  |
          *         return a 281 or 502 for this command.
929 |  |
          * @exception NNTPConnectionClosedException
930 |  |
          *      If the NNTP server prematurely closes the connection as a result
931 |  |
          *      of the client being idle or some other reason causing the server
932 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
933 |  |
          *      as an IOException or independently as itself.
934 |  |
          * @exception IOException  If an I/O error occurs while either sending the
935 |  |
          *      command or receiving the server reply.
936 |  |
          ***/
937 |  |
         public int authinfoPass(String password) throws IOException {
938 | 0 |
             String passParameter = "PASS " + password;
939 | 0 |
             return sendCommand(NNTPCommand.AUTHINFO, passParameter);
940 |  |
         }
941 |  |
942 |  |
         /***
943 |  |
          * A convenience method to send the NNTP XOVER command to the server,
944 |  |
          * receive the reply, and return the reply code.
945 |  |
          * <p>
946 |  |
          * @param selectedArticles a String representation of the range of
947 |  |
          * article headers required. This may be an article number, or a
948 |  |
          * range of article numbers in the form "XXXX-YYYY", where XXXX
949 |  |
          * and YYYY are valid article numbers in the current group.  It
950 |  |
          * also may be of the form "XXX-", meaning "return XXX and all
951 |  |
          * following articles" In this revision, the last format is not
952 |  |
          * possible (yet).
953 |  |
          * @return The reply code received from the server.
954 |  |
          * @exception NNTPConnectionClosedException
955 |  |
          *      If the NNTP server prematurely closes the connection as a result
956 |  |
          *      of the client being idle or some other reason causing the server
957 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
958 |  |
          *      as an IOException or independently as itself.
959 |  |
          * @exception IOException  If an I/O error occurs while either sending the
960 |  |
          *      command or receiving the server reply.
961 |  |
          ***/
962 |  |
         public int xover(String selectedArticles) throws IOException {
963 | 0 |
             return sendCommand(NNTPCommand.XOVER, selectedArticles);
964 |  |
         }
965 |  |
966 |  |
         /***
967 |  |
          * A convenience method to send the NNTP XHDR command to the server,
968 |  |
          * receive the reply, and return the reply code.
969 |  |
          * <p>
970 |  |
          * @param header a String naming a header line (e.g., "subject").  See
971 |  |
          * RFC-1036 for a list of valid header lines.
972 |  |
          * @param selectedArticles a String representation of the range of
973 |  |
          * article headers required. This may be an article number, or a
974 |  |
          * range of article numbers in the form "XXXX-YYYY", where XXXX
975 |  |
          * and YYYY are valid article numbers in the current group.  It
976 |  |
          * also may be of the form "XXX-", meaning "return XXX and all
977 |  |
          * following articles" In this revision, the last format is not
978 |  |
          * possible (yet).
979 |  |
          * @return The reply code received from the server.
980 |  |
          * @exception NNTPConnectionClosedException
981 |  |
          *      If the NNTP server prematurely closes the connection as a result
982 |  |
          *      of the client being idle or some other reason causing the server
983 |  |
          *      to send NNTP reply code 400.  This exception may be caught either
984 |  |
          *      as an IOException or independently as itself.
985 |  |
          * @exception IOException  If an I/O error occurs while either sending the
986 |  |
          *      command or receiving the server reply.
987 |  |
          ***/
988 |  |
         public int xhdr(String header, String selectedArticles) throws IOException {
989 | 0 |
             StringBuffer command = new StringBuffer(header);
990 | 0 |
             command.append(" ");
991 | 0 |
             command.append(selectedArticles);
992 | 0 |
             return sendCommand(NNTPCommand.XHDR, command.toString());
993 |  |
         }
994 |  |
995 |  |
         /**
996 |  |
          * A convenience wrapper for the extended LIST command that takes
997 |  |
          * an argument, allowing us to selectively list multiple groups.
998 |  |
          * <p>
999 |  |
          * @param wildmat A wildmat (pseudo-regex) pattern. See RFC 2980 for
1000 |  |
          *                details.
1001 |  |
          * @return the reply code received from the server.
1002 |  |
          * @throws IOException
1003 |  |
          */
1004 |  |
         public int listActive(String wildmat) throws IOException {
1005 | 0 |
             StringBuffer command = new StringBuffer("ACTIVE ");
1006 | 0 |
             command.append(wildmat);
1007 | 0 |
             return sendCommand(NNTPCommand.LIST, command.toString());
1008 |  |
         }
1009 |  |
     }
1010 |  |
1011 |  |
     /* Emacs configuration
1012 |  |
      * Local variables:        **
1013 |  |
      * mode:             java  **
1014 |  |
      * c-basic-offset:   4     **
1015 |  |
      * indent-tabs-mode: nil   **
1016 |  |
      * End:                    **
1017 |  |
      */

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.