unit tests coverage

Coverage report

%line %branch

org.apache.commons.net.telnet.TelnetClient
94%

99%

1
/*

2
* Copyright 2003-2004 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.telnet;

17

18
import java.io.BufferedInputStream;

19
import java.io.IOException;

20
import java.io.InputStream;

21
import java.io.OutputStream;

22
import org.apache.commons.net.io.FromNetASCIIInputStream;

23
import org.apache.commons.net.io.ToNetASCIIOutputStream;

24

25
/***

26
* The TelnetClient class implements the simple network virtual

27
* terminal (NVT) for the Telnet protocol according to RFC 854. It

28
* does not implement any of the extra Telnet options because it

29
* is meant to be used within a Java program providing automated

30
* access to Telnet accessible resources.

31
* 

32
* The class can be used by first connecting to a server using the

33
* SocketClient

34
* {@link org.apache.commons.net.SocketClient#connect connect}

35
* method. Then an InputStream and OutputStream for sending and

36
* receiving data over the Telnet connection can be obtained by

37
* using the {@link #getInputStream getInputStream() } and

38
* {@link #getOutputStream getOutputStream() } methods.

39
* When you finish using the streams, you must call

40
* {@link #disconnect disconnect } rather than simply

41
* closing the streams.

42
* 

43
* 

44
* @author Daniel F. Savarese

45
* @author Bruno D'Avanzo

46
***/

47

48
public class TelnetClient extends Telnet

49
{

50
private InputStream __input;

51
private OutputStream __output;

52 64
protected boolean readerThread = true;

53

54
/***

55
* Default TelnetClient constructor.

56
***/

57
public TelnetClient()

58
{

59
/* TERMINAL-TYPE option (start)*/

60 48
super ("VT100");

61
/* TERMINAL-TYPE option (end)*/

62 48
__input = null;

63 48
__output = null;

64 48
}

65

66
/* TERMINAL-TYPE option (start)*/

67
public TelnetClient(String termtype)

68
{

69 16
super (termtype);

70 16
__input = null;

71 16
__output = null;

72 16
}

73
/* TERMINAL-TYPE option (end)*/

74

75
void _flushOutputStream() throws IOException

76
{

77 122
_output_.flush();

78 122
}

79
void _closeOutputStream() throws IOException

80
{

81 64
_output_.close();

82 64
}

83

84
/***

85
* Handles special connection requirements.

86
* 

87
* @exception IOException If an error occurs during connection setup.

88
***/

89
protected void _connectAction_() throws IOException

90
{

91 64
super._connectAction_();

92
InputStream input;

93
TelnetInputStream tmp;

94

95 64
if (FromNetASCIIInputStream.isConversionRequired())

96 0
input = new FromNetASCIIInputStream(_input_);

97
else

98 64
input = _input_;

99

100

101 64
tmp = new TelnetInputStream(input, this, readerThread);

102 64
if(readerThread)

103
{

104 48
tmp._start();

105
}

106
// __input CANNOT refer to the TelnetInputStream. We run into

107
// blocking problems when some classes use TelnetInputStream, so

108
// we wrap it with a BufferedInputStream which we know is safe.

109
// This blocking behavior requires further investigation, but right

110
// now it looks like classes like InputStreamReader are not implemented

111
// in a safe manner.

112 64
__input = new BufferedInputStream(tmp);

113 64
__output = new ToNetASCIIOutputStream(class="keyword">new TelnetOutputStream(this));

114 64
}

115

116
/***

117
* Disconnects the telnet session, closing the input and output streams

118
* as well as the socket. If you have references to the

119
* input and output streams of the telnet connection, you should not

120
* close them yourself, but rather call disconnect to properly close

121
* the connection.

122
***/

123
public void disconnect() throws IOException

124
{

125 64
__input.close();

126 64
__output.close();

127 64
super.disconnect();

128 64
}

129

130
/***

131
* Returns the telnet connection output stream. You should not close the

132
* stream when you finish with it. Rather, you should call

133
* {@link #disconnect disconnect }.

134
* 

135
* @return The telnet connection output stream.

136
***/

137
public OutputStream getOutputStream()

138
{

139 2
return __output;

140
}

141

142
/***

143
* Returns the telnet connection input stream. You should not close the

144
* stream when you finish with it. Rather, you should call

145
* {@link #disconnect disconnect }.

146
* 

147
* @return The telnet connection input stream.

148
***/

149
public InputStream getInputStream()

150
{

151 2
return __input;

152
}

153

154
/***

155
* Returns the state of the option on the local side.

156
* 

157
* @param option - Option to be checked.

158
* 

159
* @return The state of the option on the local side.

160
***/

161
public boolean getLocalOptionState(int option)

162
{

163
/* BUG (option active when not already acknowledged) (start)*/

164 28
return (_stateIsWill(option) && _requestedWill(option));

165
/* BUG (option active when not already acknowledged) (end)*/

166
}

167

168
/***

169
* Returns the state of the option on the remote side.

170
* 

171
* @param option - Option to be checked.

172
* 

173
* @return The state of the option on the remote side.

174
***/

175
public boolean getRemoteOptionState(int option)

176
{

177
/* BUG (option active when not already acknowledged) (start)*/

178 12
return (_stateIsDo(option) && _requestedDo(option));

179
/* BUG (option active when not already acknowledged) (end)*/

180
}

181
/* open TelnetOptionHandler functionality (end)*/

182

183
/* Code Section added for supporting AYT (start)*/

184

185
/***

186
* Sends an Are You There sequence and waits for the result.

187
* 

188
* @throws InterruptedException

189
* @throws IllegalArgumentException

190
* @throws IOException

191
* 

192
* @param timeout - Time to wait for a response (millis.)

193
* 

194
* @return true if AYT received a response, false otherwise

195
***/

196
public boolean sendAYT(long timeout)

197
throws IOException, IllegalArgumentException, InterruptedException

198
{

199 4
return (_sendAYT(timeout));

200
}

201
/* Code Section added for supporting AYT (start)*/

202

203
/* open TelnetOptionHandler functionality (start)*/

204

205
/***

206
* Registers a new TelnetOptionHandler for this telnet client to use.

207
* 

208
* @throws InvalidTelnetOptionException

209
* 

210
* @param opthand - option handler to be registered.

211
***/

212
public void addOptionHandler(TelnetOptionHandler opthand)

213
throws InvalidTelnetOptionException

214
{

215 52
super.addOptionHandler(opthand);

216 48
}

217
/* open TelnetOptionHandler functionality (end)*/

218

219
/***

220
* Unregisters a TelnetOptionHandler.

221
* 

222
* @throws InvalidTelnetOptionException

223
* 

224
* @param optcode - Code of the option to be unregistered.

225
***/

226
public void deleteOptionHandler(int optcode)

227
throws InvalidTelnetOptionException

228
{

229 6
super.deleteOptionHandler(optcode);

230 2
}

231

232
/* Code Section added for supporting spystreams (start)*/

233
/***

234
* Registers an OutputStream for spying what's going on in

235
* the TelnetClient session.

236
* 

237
* @param spystream - OutputStream on which session activity

238
* will be echoed.

239
***/

240
public void registerSpyStream(OutputStream spystream)

241
{

242 2
super._registerSpyStream(spystream);

243 2
}

244

245
/***

246
* Stops spying this TelnetClient.

247
* 

248
***/

249
public void stopSpyStream()

250
{

251 2
super._stopSpyStream();

252 2
}

253
/* Code Section added for supporting spystreams (end)*/

254

255
/***

256
* Registers a notification handler to which will be sent

257
* notifications of received telnet option negotiation commands.

258
* 

259
* @param notifhand - TelnetNotificationHandler to be registered

260
***/

261
public void registerNotifHandler(TelnetNotificationHandler notifhand)

262
{

263 2
super.registerNotifHandler(notifhand);

264 2
}

265

266
/***

267
* Unregisters the current notification handler.

268
* 

269
***/

270
public void unregisterNotifHandler()

271
{

272 0
super.unregisterNotifHandler();

273 0
}

274

275
/***

276
* Sets the status of the reader thread.

277
* The reader thread status will apply to all subsequent connections

278
* 

279
* @param flag - true switches the reader thread on, false switches it off

280
***/

281
public void setReaderThread(boolean flag)

282
{

283 32
readerThread = flag;

284 32
}

285

286
/***

287
* Gets the status of the reader thread.

288
* 

289
* @return true if the reader thread is on, false otherwise

290
***/

291
public boolean getReaderThread()

292
{

293 4
return (readerThread);

294
}

295
}

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

1		/*
2		* Copyright 2003-2004 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.telnet;
17
18		import java.io.BufferedInputStream;
19		import java.io.IOException;
20		import java.io.InputStream;
21		import java.io.OutputStream;
22		import org.apache.commons.net.io.FromNetASCIIInputStream;
23		import org.apache.commons.net.io.ToNetASCIIOutputStream;
24
25		/***
26		* The TelnetClient class implements the simple network virtual
27		* terminal (NVT) for the Telnet protocol according to RFC 854. It
28		* does not implement any of the extra Telnet options because it
29		* is meant to be used within a Java program providing automated
30		* access to Telnet accessible resources.
31		* <p>
32		* The class can be used by first connecting to a server using the
33		* SocketClient
34		* {@link org.apache.commons.net.SocketClient#connect connect}
35		* method. Then an InputStream and OutputStream for sending and
36		* receiving data over the Telnet connection can be obtained by
37		* using the {@link #getInputStream getInputStream() } and
38		* {@link #getOutputStream getOutputStream() } methods.
39		* When you finish using the streams, you must call
40		* {@link #disconnect disconnect } rather than simply
41		* closing the streams.
42		* <p>
43		* <p>
44		* @author Daniel F. Savarese
45		* @author Bruno D'Avanzo
46		***/
47
48		public class TelnetClient extends Telnet
49		{
50		private InputStream __input;
51		private OutputStream __output;
52	64	protected boolean readerThread = true;
53
54		/***
55		* Default TelnetClient constructor.
56		***/
57		public TelnetClient()
58		{
59		/* TERMINAL-TYPE option (start)*/
60	48	super ("VT100");
61		/* TERMINAL-TYPE option (end)*/
62	48	__input = null;
63	48	__output = null;
64	48	}
65
66		/* TERMINAL-TYPE option (start)*/
67		public TelnetClient(String termtype)
68		{
69	16	super (termtype);
70	16	__input = null;
71	16	__output = null;
72	16	}
73		/* TERMINAL-TYPE option (end)*/
74
75		void _flushOutputStream() throws IOException
76		{
77	122	_output_.flush();
78	122	}
79		void _closeOutputStream() throws IOException
80		{
81	64	_output_.close();
82	64	}
83
84		/***
85		* Handles special connection requirements.
86		* <p>
87		* @exception IOException If an error occurs during connection setup.
88		***/
89		protected void _connectAction_() throws IOException
90		{
91	64	super._connectAction_();
92		InputStream input;
93		TelnetInputStream tmp;
94
95	64	if (FromNetASCIIInputStream.isConversionRequired())
96	0	input = new FromNetASCIIInputStream(_input_);
97		else
98	64	input = _input_;
99
100
101	64	tmp = new TelnetInputStream(input, this, readerThread);
102	64	if(readerThread)
103		{
104	48	tmp._start();
105		}
106		// __input CANNOT refer to the TelnetInputStream. We run into
107		// blocking problems when some classes use TelnetInputStream, so
108		// we wrap it with a BufferedInputStream which we know is safe.
109		// This blocking behavior requires further investigation, but right
110		// now it looks like classes like InputStreamReader are not implemented
111		// in a safe manner.
112	64	__input = new BufferedInputStream(tmp);
113	64	__output = new ToNetASCIIOutputStream(class="keyword">new TelnetOutputStream(this));
114	64	}
115
116		/***
117		* Disconnects the telnet session, closing the input and output streams
118		* as well as the socket. If you have references to the
119		* input and output streams of the telnet connection, you should not
120		* close them yourself, but rather call disconnect to properly close
121		* the connection.
122		***/
123		public void disconnect() throws IOException
124		{
125	64	__input.close();
126	64	__output.close();
127	64	super.disconnect();
128	64	}
129
130		/***
131		* Returns the telnet connection output stream. You should not close the
132		* stream when you finish with it. Rather, you should call
133		* {@link #disconnect disconnect }.
134		* <p>
135		* @return The telnet connection output stream.
136		***/
137		public OutputStream getOutputStream()
138		{
139	2	return __output;
140		}
141
142		/***
143		* Returns the telnet connection input stream. You should not close the
144		* stream when you finish with it. Rather, you should call
145		* {@link #disconnect disconnect }.
146		* <p>
147		* @return The telnet connection input stream.
148		***/
149		public InputStream getInputStream()
150		{
151	2	return __input;
152		}
153
154		/***
155		* Returns the state of the option on the local side.
156		* <p>
157		* @param option - Option to be checked.
158		* <p>
159		* @return The state of the option on the local side.
160		***/
161		public boolean getLocalOptionState(int option)
162		{
163		/* BUG (option active when not already acknowledged) (start)*/
164	28	return (_stateIsWill(option) && _requestedWill(option));
165		/* BUG (option active when not already acknowledged) (end)*/
166		}
167
168		/***
169		* Returns the state of the option on the remote side.
170		* <p>
171		* @param option - Option to be checked.
172		* <p>
173		* @return The state of the option on the remote side.
174		***/
175		public boolean getRemoteOptionState(int option)
176		{
177		/* BUG (option active when not already acknowledged) (start)*/
178	12	return (_stateIsDo(option) && _requestedDo(option));
179		/* BUG (option active when not already acknowledged) (end)*/
180		}
181		/* open TelnetOptionHandler functionality (end)*/
182
183		/* Code Section added for supporting AYT (start)*/
184
185		/***
186		* Sends an Are You There sequence and waits for the result.
187		* <p>
188		* @throws InterruptedException
189		* @throws IllegalArgumentException
190		* @throws IOException
191		* <p>
192		* @param timeout - Time to wait for a response (millis.)
193		* <p>
194		* @return true if AYT received a response, false otherwise
195		***/
196		public boolean sendAYT(long timeout)
197		throws IOException, IllegalArgumentException, InterruptedException
198		{
199	4	return (_sendAYT(timeout));
200		}
201		/* Code Section added for supporting AYT (start)*/
202
203		/* open TelnetOptionHandler functionality (start)*/
204
205		/***
206		* Registers a new TelnetOptionHandler for this telnet client to use.
207		* <p>
208		* @throws InvalidTelnetOptionException
209		* <p>
210		* @param opthand - option handler to be registered.
211		***/
212		public void addOptionHandler(TelnetOptionHandler opthand)
213		throws InvalidTelnetOptionException
214		{
215	52	super.addOptionHandler(opthand);
216	48	}
217		/* open TelnetOptionHandler functionality (end)*/
218
219		/***
220		* Unregisters a TelnetOptionHandler.
221		* <p>
222		* @throws InvalidTelnetOptionException
223		* <p>
224		* @param optcode - Code of the option to be unregistered.
225		***/
226		public void deleteOptionHandler(int optcode)
227		throws InvalidTelnetOptionException
228		{
229	6	super.deleteOptionHandler(optcode);
230	2	}
231
232		/* Code Section added for supporting spystreams (start)*/
233		/***
234		* Registers an OutputStream for spying what's going on in
235		* the TelnetClient session.
236		* <p>
237		* @param spystream - OutputStream on which session activity
238		* will be echoed.
239		***/
240		public void registerSpyStream(OutputStream spystream)
241		{
242	2	super._registerSpyStream(spystream);
243	2	}
244
245		/***
246		* Stops spying this TelnetClient.
247		* <p>
248		***/
249		public void stopSpyStream()
250		{
251	2	super._stopSpyStream();
252	2	}
253		/* Code Section added for supporting spystreams (end)*/
254
255		/***
256		* Registers a notification handler to which will be sent
257		* notifications of received telnet option negotiation commands.
258		* <p>
259		* @param notifhand - TelnetNotificationHandler to be registered
260		***/
261		public void registerNotifHandler(TelnetNotificationHandler notifhand)
262		{
263	2	super.registerNotifHandler(notifhand);
264	2	}
265
266		/***
267		* Unregisters the current notification handler.
268		* <p>
269		***/
270		public void unregisterNotifHandler()
271		{
272	0	super.unregisterNotifHandler();
273	0	}
274
275		/***
276		* Sets the status of the reader thread.
277		* The reader thread status will apply to all subsequent connections
278		* <p>
279		* @param flag - true switches the reader thread on, false switches it off
280		***/
281		public void setReaderThread(boolean flag)
282		{
283	32	readerThread = flag;
284	32	}
285
286		/***
287		* Gets the status of the reader thread.
288		* <p>
289		* @return true if the reader thread is on, false otherwise
290		***/
291		public boolean getReaderThread()
292		{
293	4	return (readerThread);
294		}
295		}