1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
//
// StringBuilderTest.dll - NUnit Test Cases for the System.Text.StringBuilder class
//
// Author: Marcin Szczepanski (marcins@zipworld.com.au)
//
// NOTES: I've also run all these tests against the MS implementation of
// System.Text.StringBuilder to confirm that they return the same results
// and they do.
//
// TODO: Add tests for the AppendFormat methods once the AppendFormat methods
// are implemented in the StringBuilder class itself
//
// TODO: Potentially add more variations on Insert / Append tests for all the
// possible types. I don't really think that's necessary as they all
// pretty much just do .ToString().ToCharArray() and then use the Append / Insert
// CharArray function. The ToString() bit for each type should be in the unit
// tests for those types, and the unit test for ToCharArray should be in the
// string test type. If someone wants to add those tests here for completness
// (and some double checking) then feel free :)
//
using NUnit.Framework;
using System.Text;
using System;
namespace MonoTests.System.Text {
public class StringBuilderTest : TestCase {
public static ITest Suite {
get {
return new TestSuite(typeof(StringBuilderTest));
}
}
public StringBuilderTest( string name ) : base(name) { }
private StringBuilder sb;
public void TestConstructor1()
{
// check the parameterless ctor
sb = new StringBuilder();
AssertEquals(String.Empty, sb.ToString());
AssertEquals(0, sb.Length);
AssertEquals(16, sb.Capacity);
}
public void TestConstructor2()
{
// check ctor that specifies the capacity
sb = new StringBuilder(10);
AssertEquals(String.Empty, sb.ToString());
AssertEquals(0, sb.Length);
// check that capacity is not less than default
AssertEquals(10, sb.Capacity);
sb = new StringBuilder(42);
AssertEquals(String.Empty, sb.ToString());
AssertEquals(0, sb.Length);
// check that capacity is set
AssertEquals(42, sb.Capacity);
}
public void TestConstructor3() {
// check ctor that specifies the capacity & maxCapacity
sb = new StringBuilder(444, 1234);
AssertEquals(String.Empty, sb.ToString());
AssertEquals(0, sb.Length);
AssertEquals(444, sb.Capacity);
AssertEquals(1234, sb.MaxCapacity);
}
public void TestConstructor4()
{
// check for exception in ctor that specifies the capacity & maxCapacity
try {
sb = new StringBuilder(9999, 15);
}
catch (ArgumentOutOfRangeException) {
return;
}
// if we didn't catch an exception, then we have a problem Houston.
NUnit.Framework.Assertion.Fail("Capacity exeeds MaxCapacity");
}
public void TestConstructor5() {
String someString = null;
sb = new StringBuilder(someString);
AssertEquals("Should be empty string", String.Empty, sb.ToString());
}
public void TestConstructor6() {
// check for exception in ctor that prevents startIndex less than zero
try {
String someString = "someString";
sb = new StringBuilder(someString, -1, 3, 18);
}
catch (ArgumentOutOfRangeException) {
return;
}
// if we didn't catch an exception, then we have a problem Houston.
NUnit.Framework.Assertion.Fail("StartIndex not allowed to be less than zero.");
}
public void TestConstructor7() {
// check for exception in ctor that prevents length less than zero
try {
String someString = "someString";
sb = new StringBuilder(someString, 2, -222, 18);
}
catch (ArgumentOutOfRangeException) {
return;
}
// if we didn't catch an exception, then we have a problem Houston.
NUnit.Framework.Assertion.Fail("Length not allowed to be less than zero.");
}
public void TestConstructor8() {
// check for exception in ctor that ensures substring is contained in given string
// check that startIndex is not too big
try {
String someString = "someString";
sb = new StringBuilder(someString, 10000, 4, 18);
}
catch (ArgumentOutOfRangeException) {
return;
}
// if we didn't catch an exception, then we have a problem Houston.
NUnit.Framework.Assertion.Fail("StartIndex and length must refer to a location within the string.");
}
public void TestConstructor9() {
// check for exception in ctor that ensures substring is contained in given string
// check that length doesn't go beyond end of string
try {
String someString = "someString";
sb = new StringBuilder(someString, 4, 4000, 18);
}
catch (ArgumentOutOfRangeException) {
return;
}
// if we didn't catch an exception, then we have a problem Houston.
NUnit.Framework.Assertion.Fail("StartIndex and length must refer to a location within the string.");
}
public void TestConstructor10() {
// check that substring is taken properly and made into a StringBuilder
String someString = "someString";
sb = new StringBuilder(someString, 4, 6, 18);
string expected = "String";
AssertEquals( expected, sb.ToString());
}
public void TestAppend() {
StringBuilder sb = new StringBuilder( "Foo" );
sb.Append( "Two" );
string expected = "FooTwo";
AssertEquals( expected, sb.ToString() );
}
public void TestInsert() {
StringBuilder sb = new StringBuilder();
AssertEquals( String.Empty, sb.ToString() );
/* Test empty StringBuilder conforms to spec */
sb.Insert( 0, "Foo" ); /* Test insert at start of empty string */
AssertEquals( "Foo", sb.ToString() );
sb.Insert( 1, "!!" ); /* Test insert not at start of string */
AssertEquals( "F!!oo", sb.ToString() );
sb.Insert( 5, ".." ); /* Test insert at end of string */
AssertEquals( "F!!oo..", sb.ToString() );
sb.Insert( 0, 1234 ); /* Test insert of a number (at start of string) */
// FIX: Why does this test fail?
//AssertEquals( "1234F!!oo..", sb.ToString() );
sb.Insert( 5, 1.5 ); /* Test insert of a decimal (and end of string) */
// FIX: Why does this test fail?
//AssertEquals( "1234F1.5!!oo..", sb.ToString() );
sb.Insert( 4, 'A' ); /* Test char insert in middle of string */
// FIX: Why does this test fail?
//AssertEquals( "1234AF1.5!!oo..", sb.ToString() );
}
public void TestReplace() {
StringBuilder sb = new StringBuilder( "Foobarbaz" );
sb.Replace( "bar", "!!!" ); /* Test same length replace in middle of string */
AssertEquals( "Foo!!!baz", sb.ToString() );
sb.Replace( "Foo", "ABcD" ); /* Test longer replace at start of string */
AssertEquals( "ABcD!!!baz", sb.ToString() );
sb.Replace( "baz", "00" ); /* Test shorter replace at end of string */
AssertEquals( "ABcD!!!00", sb.ToString() );
sb.Replace( sb.ToString(), null ); /* Test string clear as in spec */
AssertEquals( String.Empty, sb.ToString() );
/* | 10 20 30
/* |0123456789012345678901234567890| */
sb.Append( "abc this is testing abc the abc abc partial replace abc" );
sb.Replace( "abc", "!!!", 0, 31 ); /* Partial replace at start of string */
AssertEquals( "!!! this is testing !!! the !!! abc partial replace abc", sb.ToString() );
sb.Replace( "testing", "", 0, 15 ); /* Test replace across boundary */
AssertEquals( "!!! this is testing !!! the !!! abc partial replace abc", sb.ToString() );
sb.Replace( "!!!", "" ); /* Test replace with empty string */
AssertEquals(" this is testing the abc partial replace abc", sb.ToString() );
}
public void TestAppendFormat() {
}
}
}
|
