← Back to branch summary

~nunit-core/nunitv2/2.5

« back to all changes in this revision

Viewing changes to src/NUnitCore/core/StringTextWriter.cs

  • Committer: charliepoole
  • Date: 2006-01-06 01:08:17 UTC
  • Revision ID: vcs-imports@canonical.com-20060106010817-z6xazs4kd89zj8j1
Move core from under NUnitFramework to NUnitCore directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/NUnitCore/core/StringTextWriter.cs
 
1
#region Copyright (c) 2002-2003, James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole, Philip A. Craig
 
2
/************************************************************************************
 
3
'
 
4
' Copyright � 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole
 
5
' Copyright � 2000-2003 Philip A. Craig
 
6
'
 
7
' This software is provided 'as-is', without any express or implied warranty. In no 
 
8
' event will the authors be held liable for any damages arising from the use of this 
 
9
' software.
 
10
' 
 
11
' Permission is granted to anyone to use this software for any purpose, including 
 
12
' commercial applications, and to alter it and redistribute it freely, subject to the 
 
13
' following restrictions:
 
14
'
 
15
' 1. The origin of this software must not be misrepresented; you must not claim that 
 
16
' you wrote the original software. If you use this software in a product, an 
 
17
' acknowledgment (see the following) in the product documentation is required.
 
18
'
 
19
' Portions Copyright � 2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole
 
20
' or Copyright � 2000-2003 Philip A. Craig
 
21
'
 
22
' 2. Altered source versions must be plainly marked as such, and must not be 
 
23
' misrepresented as being the original software.
 
24
'
 
25
' 3. This notice may not be removed or altered from any source distribution.
 
26
'
 
27
'***********************************************************************************/
 
28
#endregion
 
29
 
 
30
using System.IO;
 
31
using System.Text;
 
32
 
 
33
namespace NUnit.Core
 
34
{
 
35
        // TODO: This class is not currently being used. Review to
 
36
        // see if we will use it again, otherwise drop it.
 
37
        #region StringTextWriter
 
38
 
 
39
        /// <summary>
 
40
        /// Use this wrapper to ensure that only strings get passed accross the AppDomain
 
41
        /// boundary.  Otherwise tests will break when non-remotable objects are passed to
 
42
        /// Console.Write/WriteLine.
 
43
        /// </summary>
 
44
        public class StringTextWriter : TextWriter
 
45
        {
 
46
                public StringTextWriter( TextWriter aTextWriter )
 
47
                {
 
48
                        theTextWriter = aTextWriter;
 
49
                }
 
50
 
 
51
                protected TextWriter theTextWriter;
 
52
 
 
53
                override public void Write(char aChar)
 
54
                {
 
55
                        theTextWriter.Write(aChar);
 
56
                }
 
57
 
 
58
                override public void Write(string aString)
 
59
                {
 
60
                        theTextWriter.Write(aString);
 
61
                }
 
62
 
 
63
                override public void WriteLine(string aString)
 
64
                {
 
65
                        theTextWriter.WriteLine(aString);
 
66
                }
 
67
 
 
68
                override public System.Text.Encoding Encoding
 
69
                {
 
70
                        get { return theTextWriter.Encoding; }
 
71
                }
 
72
 
 
73
                public override void Close()
 
74
                {
 
75
                        this.Flush();
 
76
                        theTextWriter.Close ();
 
77
                }
 
78
 
 
79
                public override void Flush()
 
80
                {
 
81
                        theTextWriter.Flush ();
 
82
                }
 
83
        }
 
84
 
 
85
        #endregion
 
86
 
 
87
        #region BufferedStringTextWriter
 
88
 
 
89
        /// <summary>
 
90
        /// This wrapper derives from StringTextWriter and adds buffering
 
91
        /// to improve cross-domain performance. The buffer is flushed whenever
 
92
        /// it reaches or exceeds a maximum size or when Flush is called.
 
93
        /// </summary>
 
94
        public class BufferedStringTextWriter : StringTextWriter
 
95
        {
 
96
                public BufferedStringTextWriter( TextWriter aTextWriter ) : base( aTextWriter ){ }
 
97
        
 
98
                private static readonly int MAX_BUFFER = 1000;
 
99
                private StringBuilder sb = new StringBuilder( MAX_BUFFER );
 
100
 
 
101
                override public void Write(char aChar)
 
102
                {
 
103
                        lock( sb )
 
104
                        {
 
105
                                sb.Append( aChar );
 
106
                                this.CheckBuffer();
 
107
                        }
 
108
                }
 
109
 
 
110
                override public void Write(string aString)
 
111
                {
 
112
                        lock( sb )
 
113
                        {
 
114
                                sb.Append( aString );
 
115
                                this.CheckBuffer();
 
116
                        }
 
117
                }
 
118
 
 
119
                override public void WriteLine(string aString)
 
120
                {
 
121
                        lock( sb )
 
122
                        {
 
123
                                sb.Append( aString );
 
124
                                sb.Append( '\n' );
 
125
                                this.CheckBuffer();
 
126
                        }
 
127
                }
 
128
 
 
129
                override public void Flush()
 
130
                {
 
131
                        if ( sb.Length > 0 )
 
132
                        {
 
133
                                lock( sb )
 
134
                                {
 
135
                                        theTextWriter.Write( sb.ToString() );
 
136
                                        sb.Length = 0;
 
137
                                }
 
138
                        }
 
139
 
 
140
                        theTextWriter.Flush();
 
141
                }
 
142
 
 
143
                private void CheckBuffer()
 
144
                {
 
145
                        if ( sb.Length >= MAX_BUFFER )
 
146
                                this.Flush();
 
147
                }
 
148
        }
 
149
 
 
150
        #endregion
 
151
}