Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.FingerClient |
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;
17 |  |
18 |  |
     import java.io.BufferedReader;
19 |  |
     import java.io.IOException;
20 |  |
     import java.io.InputStream;
21 |  |
     import java.io.InputStreamReader;
22 |  |
     import java.io.BufferedOutputStream;
23 |  |
     import java.io.DataOutputStream;
24 |  |
25 |  |
     /***
26 |  |
      * The FingerClient class implements the client side of the Internet Finger
27 |  |
      * Protocol defined in RFC 1288.  To finger a host you create a
28 |  |
      * FingerClient instance, connect to the host, query the host, and finally
29 |  |
      * disconnect from the host.  If the finger service you want to query is on
30 |  |
      * a non-standard port, connect to the host at that port.
31 |  |
      * Here's a sample use:
32 |  |
      * <pre>
33 |  |
      *    FingerClient finger;
34 |  |
      *
35 |  |
      *    finger = new FingerClient();
36 |  |
      *
37 |  |
      *    try {
38 |  |
      *      finger.connect("foo.bar.com");
39 |  |
      *      System.out.println(finger.query("foobar", false));
40 |  |
      *      finger.disconnect();
41 |  |
      *    } catch(IOException e) {
42 |  |
      *      System.err.println("Error I/O exception: " + e.getMessage());
43 |  |
      *      return;
44 |  |
      *    }
45 |  |
      * </pre>
46 |  |
      * <p>
47 |  |
      * <p>
48 |  |
      * @author Daniel F. Savarese
49 |  |
      ***/
50 |  |
51 |  |
     public class FingerClient extends SocketClient
52 |  |
     {
53 |  |
         /***
54 |  |
          * The default FINGER port.  Set to 79 according to RFC 1288.
55 |  |
          ***/
56 |  |
         public static final int DEFAULT_PORT = 79;
57 |  |
58 |  |
         private static final String __LONG_FLAG = "/W ";
59 |  |
60 | 0 |
         private transient StringBuffer __query = new StringBuffer(64);
61 | 0 |
         private transient char[] __buffer = new class="keyword">char[1024];
62 |  |
63 |  |
         /***
64 |  |
          * The default FingerClient constructor.  Initializes the
65 |  |
          * default port to <code> DEFAULT_PORT </code>.
66 |  |
          ***/
67 |  |
         public FingerClient()
68 | 0 |
         {
69 | 0 |
             setDefaultPort(DEFAULT_PORT);
70 | 0 |
         }
71 |  |
72 |  |
73 |  |
         /***
74 |  |
          * Fingers a user at the connected host and returns the output
75 |  |
          * as a String.  You must first connect to a finger server before
76 |  |
          * calling this method, and you should disconnect afterward.
77 |  |
          * <p>
78 |  |
          * @param longOutput Set to true if long output is requested, false if not.
79 |  |
          * @param username  The name of the user to finger.
80 |  |
          * @return The result of the finger query.
81 |  |
          * @exception IOException If an I/O error occurs while reading the socket.
82 |  |
          ***/
83 |  |
         public String query(boolean longOutput, String username) throws IOException
84 |  |
         {
85 |  |
             int read;
86 | 0 |
             StringBuffer result = new StringBuffer(__buffer.length);
87 |  |
             BufferedReader input;
88 |  |
89 | 0 |
             input =
90 |  |
                 new BufferedReader(class="keyword">new InputStreamReader(getInputStream(longOutput,
91 |  |
                                    username)));
92 |  |
93 |  |
             while (true)
94 |  |
             {
95 | 0 |
                 read = input.read(__buffer, 0, __buffer.length);
96 | 0 |
                 if (read <= 0)
97 | 0 |
                     break;
98 | 0 |
                 result.append(__buffer, 0, read);
99 |  |
             }
100 |  |
101 | 0 |
             input.close();
102 |  |
103 | 0 |
             return result.toString();
104 |  |
         }
105 |  |
106 |  |
107 |  |
         /***
108 |  |
          * Fingers the connected host and returns the output
109 |  |
          * as a String.  You must first connect to a finger server before
110 |  |
          * calling this method, and you should disconnect afterward.
111 |  |
          * This is equivalent to calling <code> query(longOutput, "") </code>.
112 |  |
          * <p>
113 |  |
          * @param longOutput Set to true if long output is requested, false if not.
114 |  |
          * @return The result of the finger query.
115 |  |
          * @exception IOException If an I/O error occurs while reading the socket.
116 |  |
          ***/
117 |  |
         public String query(boolean longOutput) throws IOException
118 |  |
         {
119 | 0 |
             return query(longOutput, "");
120 |  |
         }
121 |  |
122 |  |
123 |  |
         /***
124 |  |
          * Fingers a user and returns the input stream from the network connection
125 |  |
          * of the finger query.  You must first connect to a finger server before
126 |  |
          * calling this method, and you should disconnect after finishing reading
127 |  |
          * the stream.
128 |  |
          * <p>
129 |  |
          * @param longOutput Set to true if long output is requested, false if not.
130 |  |
          * @param username  The name of the user to finger.
131 |  |
          * @return The InputStream of the network connection of the finger query.
132 |  |
          *         Can be read to obtain finger results.
133 |  |
          * @exception IOException If an I/O error during the operation.
134 |  |
          ***/
135 |  |
         public InputStream getInputStream(boolean longOutput, String username)
136 |  |
         throws IOException
137 |  |
         {
138 |  |
             DataOutputStream output;
139 |  |
140 | 0 |
             __query.setLength(0);
141 | 0 |
             if (longOutput)
142 | 0 |
                 __query.append(__LONG_FLAG);
143 | 0 |
             __query.append(username);
144 | 0 |
             __query.append(SocketClient.NETASCII_EOL);
145 |  |
146 | 0 |
             output =
147 |  |
               new DataOutputStream(class="keyword">new BufferedOutputStream(_output_, 1024));
148 | 0 |
             output.writeBytes(__query.toString());
149 | 0 |
             output.flush();
150 |  |
151 | 0 |
             return _input_;
152 |  |
         }
153 |  |
154 |  |
155 |  |
         /***
156 |  |
          * Fingers the connected host and returns the input stream from
157 |  |
          * the network connection of the finger query.  This is equivalent to
158 |  |
          * calling getInputStream(longOutput, "").  You must first connect to a
159 |  |
          * finger server before calling this method, and you should disconnect
160 |  |
          * after finishing reading the stream.
161 |  |
          * <p>
162 |  |
          * @param longOutput Set to true if long output is requested, false if not.
163 |  |
          * @return The InputStream of the network connection of the finger query.
164 |  |
          *         Can be read to obtain finger results.
165 |  |
          * @exception IOException If an I/O error during the operation.
166 |  |
          ***/
167 |  |
         public InputStream getInputStream(boolean longOutput) throws IOException
168 |  |
         {
169 | 0 |
             return getInputStream(longOutput, "");
170 |  |
         }
171 |  |
172 |  |
     }

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