Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.io.FromNetASCIIInputStream |
13% |
62% |

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.io;
17 |  |
18 |  |
     import java.io.IOException;
19 |  |
     import java.io.InputStream;
20 |  |
     import java.io.PushbackInputStream;
21 |  |
22 |  |
     /***
23 |  |
      * This class wraps an input stream, replacing all occurrences
24 |  |
      * of &lt;CR&gt;&lt;LF&gt; (carriage return followed by a linefeed),
25 |  |
      * which is the NETASCII standard for representing a newline, with the
26 |  |
      * local line separator representation.  You would use this class to
27 |  |
      * implement ASCII file transfers requiring conversion from NETASCII.
28 |  |
      * <p>
29 |  |
      * <p>
30 |  |
      * @author Daniel F. Savarese
31 |  |
      ***/
32 |  |
33 |  |
     public final class FromNetASCIIInputStream extends PushbackInputStream
34 |  |
     {
35 |  |
         static final boolean _noConversionRequired;
36 |  |
         static final String _lineSeparator;
37 |  |
         static final byte[] _lineSeparatorBytes;
38 |  |
39 |  |
         static {
40 | 2 |
             _lineSeparator = System.getProperty("line.separator");
41 | 2 |
             _noConversionRequired = _lineSeparator.equals("\r\n");
42 | 2 |
             _lineSeparatorBytes = _lineSeparator.getBytes();
43 | 2 |
         }
44 |  |
45 | 0 |
         private int __length = 0;
46 |  |
47 |  |
         /***
48 |  |
          * Returns true if the NetASCII line separator differs from the system
49 |  |
          * line separator, false if they are the same.  This method is useful
50 |  |
          * to determine whether or not you need to instantiate a
51 |  |
          * FromNetASCIIInputStream object.
52 |  |
          * <p>
53 |  |
          * @return True if the NETASCII line separator differs from the local
54 |  |
          *   system line separator, false if they are the same.
55 |  |
          ***/
56 |  |
         public static final boolean isConversionRequired()
57 |  |
         {
58 | 64 |
             return !_noConversionRequired;
59 |  |
         }
60 |  |
61 |  |
         /***
62 |  |
          * Creates a FromNetASCIIInputStream instance that wraps an existing
63 |  |
          * InputStream.
64 |  |
          ***/
65 |  |
         public FromNetASCIIInputStream(InputStream input)
66 |  |
         {
67 | 0 |
             super(input, _lineSeparatorBytes.length + 1);
68 | 0 |
         }
69 |  |
70 |  |
71 |  |
         private int __read() throws IOException
72 |  |
         {
73 |  |
             int ch;
74 |  |
75 | 0 |
             ch = super.read();
76 |  |
77 | 0 |
             if (ch == '\r')
78 |  |
             {
79 | 0 |
                 ch = super.read();
80 | 0 |
                 if (ch == '\n')
81 |  |
                 {
82 | 0 |
                     unread(_lineSeparatorBytes);
83 | 0 |
                     ch = super.read();
84 |  |
                     // This is a kluge for read(byte[], ...) to read the right amount
85 | 0 |
                     --__length;
86 |  |
                 }
87 |  |
                 else
88 |  |
                 {
89 | 0 |
                     if (ch != -1)
90 | 0 |
                         unread(ch);
91 | 0 |
                     return '\r';
92 |  |
                 }
93 |  |
             }
94 |  |
95 | 0 |
             return ch;
96 |  |
         }
97 |  |
98 |  |
99 |  |
         /***
100 |  |
          * Reads and returns the next byte in the stream.  If the end of the
101 |  |
          * message has been reached, returns -1.  Note that a call to this method
102 |  |
          * may result in multiple reads from the underlying input stream in order
103 |  |
          * to convert NETASCII line separators to the local line separator format.
104 |  |
          * This is transparent to the programmer and is only mentioned for
105 |  |
          * completeness.
106 |  |
          * <p>
107 |  |
          * @return The next character in the stream. Returns -1 if the end of the
108 |  |
          *          stream has been reached.
109 |  |
          * @exception IOException If an error occurs while reading the underlying
110 |  |
          *            stream.
111 |  |
          ***/
112 |  |
         public int read() throws IOException
113 |  |
         {
114 | 0 |
             if (_noConversionRequired)
115 | 0 |
                 return super.read();
116 |  |
117 | 0 |
             return __read();
118 |  |
         }
119 |  |
120 |  |
121 |  |
         /***
122 |  |
          * Reads the next number of bytes from the stream into an array and
123 |  |
          * returns the number of bytes read.  Returns -1 if the end of the
124 |  |
          * stream has been reached.
125 |  |
          * <p>
126 |  |
          * @param buffer  The byte array in which to store the data.
127 |  |
          * @return The number of bytes read. Returns -1 if the
128 |  |
          *          end of the message has been reached.
129 |  |
          * @exception IOException If an error occurs in reading the underlying
130 |  |
          *            stream.
131 |  |
          ***/
132 |  |
         public int read(byte buffer[]) throws IOException
133 |  |
         {
134 | 0 |
             return read(buffer, 0, buffer.length);
135 |  |
         }
136 |  |
137 |  |
138 |  |
         /***
139 |  |
          * Reads the next number of bytes from the stream into an array and returns
140 |  |
          * the number of bytes read.  Returns -1 if the end of the
141 |  |
          * message has been reached.  The characters are stored in the array
142 |  |
          * starting from the given offset and up to the length specified.
143 |  |
          * <p>
144 |  |
          * @param buffer The byte array in which to store the data.
145 |  |
          * @param offset  The offset into the array at which to start storing data.
146 |  |
          * @param length   The number of bytes to read.
147 |  |
          * @return The number of bytes read. Returns -1 if the
148 |  |
          *          end of the stream has been reached.
149 |  |
          * @exception IOException If an error occurs while reading the underlying
150 |  |
          *            stream.
151 |  |
          ***/
152 |  |
         public int read(byte buffer[], class="keyword">int offset, class="keyword">int length) throws IOException
153 |  |
         {
154 |  |
             int ch, off;
155 |  |
156 | 0 |
             if (length < 1)
157 | 0 |
                 return 0;
158 |  |
159 | 0 |
             ch = available();
160 |  |
161 | 0 |
             __length = (length > ch ? ch : length);
162 |  |
163 |  |
             // If nothing is available, block to read only one character
164 | 0 |
             if (__length < 1)
165 | 0 |
                 __length = 1;
166 |  |
167 | 0 |
             if (_noConversionRequired)
168 | 0 |
                 return super.read(buffer, offset, __length);
169 |  |
170 | 0 |
             if ((ch = __read()) == -1)
171 | 0 |
                 return -1;
172 |  |
173 | 0 |
             off = offset;
174 |  |
175 |  |
             do
176 |  |
             {
177 | 0 |
                 buffer[offset++] = (byte)ch;
178 |  |
             }
179 | 0 |
             while (--__length > 0 && (ch = __read()) != -1);
180 |  |
181 |  |
182 | 0 |
             return (offset - off);
183 |  |
         }
184 |  |
185 |  |
186 |  |
         // PushbackInputStream in JDK 1.1.3 returns the wrong thing
187 |  |
         /***
188 |  |
          * Returns the number of bytes that can be read without blocking EXCEPT
189 |  |
          * when newline conversions have to be made somewhere within the
190 |  |
          * available block of bytes.  In other words, you really should not
191 |  |
          * rely on the value returned by this method if you are trying to avoid
192 |  |
          * blocking.
193 |  |
          ***/
194 |  |
         public int available() throws IOException
195 |  |
         {
196 | 0 |
             return (buf.length - pos) + in.available();
197 |  |
         }
198 |  |
199 |  |
     }

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