CppUnit project page | FAQ

Stream.h
Go to the documentation of this file.
1#ifndef CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
2#define CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
3
4// This module define:
5// Type CppUT::Stream (either std::stream or a custom type)
6// Type CppUT::OStringStream (eitjer std::ostringstream, older alternate or a custom type)
7// Functions stdCOut() & stdCErr() which returns a reference on cout & cerr stream (or our
8// custom stream).
9
10#include <cppunit/Portability.h>
11
12
13#if defined( CPPUNIT_NO_STREAM )
14
15#include <string>
16#include <stdio.h>
17#include <string.h>
18
19 CPPUNIT_NS_BEGIN
20
21 class StreamBuffer
22{
23 public:
24 virtual ~StreamBuffer() {}
25
26 virtual void write( const char *text, unsigned int length ) = 0;
27
28 virtual void flush() {}
29};
30
31
32 class StringStreamBuffer : public StreamBuffer
33{
34 public:
35 std::string str() const
36 {
37 return str_;
38 }
39
40 public: // overridden from StreamBuffer
41 void write( const char *text, unsigned int length )
42 {
43 str_.append( text, length );
44 }
45
46 private:
47 std::string str_;
48};
49
50
51 class FileStreamBuffer : public StreamBuffer
52{
53 public:
54 FileStreamBuffer( FILE *file )
55 : file_( file )
56 {
57 }
58
59 FILE *file() const
60 {
61 return file_;
62 }
63
64 public: // overridden from StreamBuffer
65 void write( const char *text, unsigned int length )
66 {
67 if ( file_ )
68 fwrite( text, sizeof(char), length, file_ );
69 }
70
71 void flush()
72 {
73 if ( file_ )
74 fflush( file_ );
75 }
76
77 private:
78 FILE *file_;
79};
80
81
82 class OStream
83{
84 public:
85 OStream()
86 : buffer_( 0 )
87 {
88 }
89
90 OStream( StreamBuffer *buffer )
91 : buffer_( buffer )
92 {
93 }
94
95 virtual ~OStream()
96 {
97 flush();
98 }
99
100 OStream &flush()
101 {
102 if ( buffer_ )
103 buffer_->flush();
104 return *this;
105 }
106
107 void setBuffer( StreamBuffer *buffer )
108 {
109 buffer_ = buffer;
110 }
111
112 OStream &write( const char *text, unsigned int length )
113 {
114 if ( buffer_ )
115 buffer_->write( text, length );
116 return *this;
117 }
118
119 OStream &write( const char *text )
120 {
121 return write( text, strlen(text) );
122 }
123
124 OStream &operator <<( bool v )
125 {
126 const char *out = v ? "true" : "false";
127 return write( out );
128 }
129
130 OStream &operator <<( short v )
131 {
132 char buffer[64];
133 sprintf( buffer, "%hd", v );
134 return write( buffer );
135 }
136
137 OStream &operator <<( unsigned short v )
138 {
139 char buffer[64];
140 sprintf( buffer, "%hu", v );
141 return write( buffer );
142 }
143
144 OStream &operator <<( int v )
145 {
146 char buffer[64];
147 sprintf( buffer, "%d", v );
148 return write( buffer );
149 }
150
151 OStream &operator <<( unsigned int v )
152 {
153 char buffer[64];
154 sprintf( buffer, "%u", v );
155 return write( buffer );
156 }
157
158 OStream &operator <<( long v )
159 {
160 char buffer[64];
161 sprintf( buffer, "%ld", v );
162 return write( buffer );
163 }
164
165 OStream &operator <<( unsigned long v )
166 {
167 char buffer[64];
168 sprintf( buffer, "%lu", v );
169 return write( buffer );
170 }
171
172 OStream &operator <<( float v )
173 {
174 char buffer[128];
175 sprintf( buffer, "%.16g", double(v) );
176 return write( buffer );
177 }
178
179 OStream &operator <<( double v )
180 {
181 char buffer[128];
182 sprintf( buffer, "%.16g", v );
183 return write( buffer );
184 }
185
186 OStream &operator <<( long double v )
187 {
188 char buffer[128];
189 sprintf( buffer, "%.16g", double(v) );
190 return write( buffer );
191 }
192
193 OStream &operator <<( const void *v )
194 {
195 char buffer[64];
196 sprintf( buffer, "%p", v );
197 return write( buffer );
198 }
199
200 OStream &operator <<( const char *v )
201 {
202 return write( v ? v : "NULL" );
203 }
204
205 OStream &operator <<( char c )
206 {
207 char buffer[16];
208 sprintf( buffer, "%c", c );
209 return write( buffer );
210 }
211
212 OStream &operator <<( const std::string &s )
213 {
214 return write( s.c_str(), s.length() );
215 }
216
217 private:
218 StreamBuffer *buffer_;
219};
220
221
222 class OStringStream : public OStream
223{
224 public:
225 OStringStream()
226 : OStream( &buffer_ )
227 {
228 }
229
230 std::string str() const
231 {
232 return buffer_.str();
233 }
234
235 private:
236 StringStreamBuffer buffer_;
237};
238
239
240 class OFileStream : public OStream
241{
242 public:
243 OFileStream( FILE *file )
244 : OStream( &buffer_ )
245 , buffer_( file )
246 , ownFile_( false )
247 {
248 }
249
250 OFileStream( const char *path )
251 : OStream( &buffer_ )
252 , buffer_( fopen( path, "wt" ) )
253 , ownFile_( true )
254 {
255 }
256
257 virtual ~OFileStream()
258 {
259 if ( ownFile_ && buffer_.file() )
260 fclose( buffer_.file() );
261 }
262
263 private:
264 FileStreamBuffer buffer_;
265 bool ownFile_;
266};
267
268 inline OStream &stdCOut()
269{
270 static OFileStream stream( stdout );
271 return stream;
272}
273
274 inline OStream &stdCErr()
275{
276 static OFileStream stream( stderr );
277 return stream;
278}
279
280 CPPUNIT_NS_END
281
282#elif CPPUNIT_HAVE_SSTREAM // #if defined( CPPUNIT_NO_STREAM )
283# include <sstream>
284# include <fstream>
285
286 CPPUNIT_NS_BEGIN
287 typedef std::ostringstream OStringStream; // The standard C++ way
288 typedef std::ofstream OFileStream;
289 CPPUNIT_NS_END
290
291
292#elif CPPUNIT_HAVE_CLASS_STRSTREAM
293# include <string>
294# if CPPUNIT_HAVE_STRSTREAM
295# include <strstream>
296# else // CPPUNIT_HAVE_STRSTREAM
297# include <strstream.h>
298# endif // CPPUNIT_HAVE_CLASS_STRSTREAM
299
300 CPPUNIT_NS_BEGIN
301
302 class OStringStream : public std::ostrstream
303 {
304 public:
305 std::string str()
306 {
307// (*this) << '\0';
308// std::string msg(std::ostrstream::str());
309// std::ostrstream::freeze(false);
310// return msg;
311// Alternative implementation that don't rely on freeze which is not
312// available on some platforms:
313 return std::string( std::ostrstream::str(), pcount() );
314 }
315 };
316
317 CPPUNIT_NS_END
318#else // CPPUNIT_HAVE_CLASS_STRSTREAM
319# error Cannot define CppUnit::OStringStream.
320#endif // #if defined( CPPUNIT_NO_STREAM )
321
322
323
324#if !defined( CPPUNIT_NO_STREAM )
325
326#include <iostream>
327
328 CPPUNIT_NS_BEGIN
329
330 typedef std::ostream OStream;
331
332 inline OStream &stdCOut()
333 {
334 return std::cout;
335 }
336
337 inline OStream &stdCErr()
338 {
339 return std::cerr;
340 }
341
342 CPPUNIT_NS_END
343
344#endif // #if !defined( CPPUNIT_NO_STREAM )
345
346#endif // CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
347
Portability.h
CPPUNIT_NS_END
#define CPPUNIT_NS_END
Definition Portability.h:106
CPPUNIT_NS_BEGIN
#define CPPUNIT_NS_BEGIN
Definition Portability.h:105
stdCErr
OStream & stdCErr()
Definition Stream.h:337
stdCOut
OStream & stdCOut()
Definition Stream.h:332
OStream
CPPUNIT_NS_BEGIN typedef std::ostream OStream
Definition Stream.h:330
operator<<
CPPUNIT_API OStream & operator<<(OStream &stream, TextTestResult &result)
insertion operator for easy output
Definition TextTestResult.cpp:43

| Send comments to: CppUnit Developers