?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[Cleanup] Removed TARGET_JVM
[mono-project.git] / mcs / class / corlib / Test / System / StringTest.cs
blobb34efa5cbc81bd92a329a2e8ff43dcdb378f869b
1 // StringTest.cs - NUnit Test Cases for the System.String class
2 //
3 // Authors:
4 // Jeffrey Stedfast <fejj@ximian.com>
5 // David Brandt <bucky@keystreams.com>
6 // Kornel Pal <http://www.kornelpal.hu/>
7 //
8 // (C) Ximian, Inc. http://www.ximian.com
9 // Copyright (C) 2006 Kornel Pal
10 // Copyright (C) 2006 Novell (http://www.novell.com)
11 //
12
13 using System;
14 using System.Text;
15 using System.Globalization;
16 using System.Reflection;
17 using System.Threading;
18
19 using NUnit.Framework;
20
21 namespace MonoTests.System
22 {
23
24 [TestFixture]
25 public class StringTest
26 {
27 class NullFormatter : IFormatProvider, ICustomFormatter
28 {
29 public string Format (string format, object arg, IFormatProvider provider)
30 {
31 return null;
32 }
33
34 public object GetFormat (Type formatType)
35 {
36 return this;
37 }
38 }
39
40 class ToNullStringer
41 {
42 public override string ToString()
43 {
44 return null;
45 }
46 }
47
48 private CultureInfo orgCulture;
49
50 [SetUp]
51 public void SetUp ()
52 {
53 // save current culture
54 orgCulture = CultureInfo.CurrentCulture;
55 }
56
57 [TearDown]
58 public void TearDown ()
59 {
60 // restore original culture
61 Thread.CurrentThread.CurrentCulture = orgCulture;
62 }
63
64
65 [Test] // ctor (Char [])
66 public unsafe void Constructor2 ()
67 {
68 Assert.AreEqual (String.Empty, new String ((char[]) null), "#1");
69 Assert.AreEqual (String.Empty, new String (new Char [0]), "#2");
70 Assert.AreEqual ("A", new String (new Char [1] {'A'}), "#3");
71 }
72
73 [Test] // ctor (Char, Int32)
74 public void Constructor4 ()
75 {
76 Assert.AreEqual (string.Empty, new String ('A', 0));
77 Assert.AreEqual (new String ('A', 3), "AAA");
78 }
79
80 [Test] // ctor (Char, Int32)
81 public void Constructor4_Count_Negative ()
82 {
83 try {
84 new String ('A', -1);
85 Assert.Fail ("#1");
86 } catch (ArgumentOutOfRangeException ex) {
87 // 'count' must be non-negative
88 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
89 Assert.IsNull (ex.InnerException, "#3");
90 Assert.IsNotNull (ex.Message, "#4");
91 Assert.AreEqual ("count", ex.ParamName, "#5");
92 }
93 }
94
95 [Test] // ctor (Char [], Int32, Int32)
96 public void Constructor6 ()
97 {
98 char [] arr = new char [3] { 'A', 'B', 'C' };
99 Assert.AreEqual ("ABC", new String (arr, 0, arr.Length), "#1");
100 Assert.AreEqual ("BC", new String (arr, 1, 2), "#2");
101 Assert.AreEqual (string.Empty, new String (arr, 2, 0), "#3");
102 }
103
104 [Test] // ctor (Char [], Int32, Int32)
105 public void Constructor6_Length_Negative ()
106 {
107 char [] arr = new char [3] { 'A', 'B', 'C' };
108
109 try {
110 new String (arr, 0, -1);
111 Assert.Fail ("#1");
112 } catch (ArgumentOutOfRangeException ex) {
113 // Length cannot be less than zero
114 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
115 Assert.IsNull (ex.InnerException, "#3");
116 Assert.IsNotNull (ex.Message, "#4");
117 Assert.AreEqual ("length", ex.ParamName, "#5");
118 }
119 }
120
121 [Test] // ctor (Char [], Int32, Int32)
122 public void Constructor6_Length_Overflow ()
123 {
124 char [] arr = new char [3] { 'A', 'B', 'C' };
125
126 try {
127 new String (arr, 1, 3);
128 Assert.Fail ("#1");
129 } catch (ArgumentOutOfRangeException ex) {
130 // Index was out of range. Must be non-negative and
131 // less than the size of the collection
132 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
133 Assert.IsNull (ex.InnerException, "#3");
134 Assert.IsNotNull (ex.Message, "#4");
135 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
136 }
137 }
138
139 [Test] // ctor (Char [], Int32, Int32)
140 public void Constructor6_StartIndex_Negative ()
141 {
142 char [] arr = new char [3] { 'A', 'B', 'C' };
143
144 try {
145 new String (arr, -1, 0);
146 Assert.Fail ("#1");
147 } catch (ArgumentOutOfRangeException ex) {
148 // StartIndex cannot be less than zero
149 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
150 Assert.IsNull (ex.InnerException, "#3");
151 Assert.IsNotNull (ex.Message, "#4");
152 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
153 }
154 }
155
156 [Test] // ctor (Char [], Int32, Int32)
157 public void Constructor6_Value_Null ()
158 {
159 try {
160 new String ((char []) null, 0, 0);
161 Assert.Fail ("#1");
162 } catch (ArgumentNullException ex) {
163 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
164 Assert.IsNull (ex.InnerException, "#3");
165 Assert.IsNotNull (ex.Message, "#4");
166 Assert.AreEqual ("value", ex.ParamName, "#5");
167 }
168 }
169
170 [Test]
171 public unsafe void CharPtrConstructor ()
172 {
173 Assert.AreEqual (String.Empty, new String ((char*) null), "char*");
174 Assert.AreEqual (String.Empty, new String ((char*) null, 0, 0), "char*,int,int");
175 }
176
177 [Test]
178 public unsafe void TestSbytePtrConstructorASCII ()
179 {
180 Encoding encoding = Encoding.ASCII;
181 String s = "ASCII*\0";
182 byte[] bytes = encoding.GetBytes (s);
183
184 fixed (byte* bytePtr = bytes)
185 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding));
186 }
187
188 [Test]
189 public unsafe void TestSbytePtrConstructorDefault ()
190 {
191 Encoding encoding = Encoding.Default;
192 byte [] bytes = new byte [256];
193
194 for (int i = 0; i < 255; i++)
195 bytes [i] = (byte) (i + 1);
196 bytes [255] = (byte) 0;
197
198 // Ensure that bytes are valid for Encoding.Default
199 bytes = encoding.GetBytes (encoding.GetChars (bytes));
200 String s = encoding.GetString(bytes);
201
202 // Ensure null terminated array
203 bytes [bytes.Length - 1] = (byte) 0;
204
205 fixed (byte* bytePtr = bytes)
206 {
207 Assert.AreEqual (s.Substring (0, s.Length - 1), new String ((sbyte*) bytePtr));
208 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length));
209 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, null));
210 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding));
211 }
212 }
213
214 [Test] // ctor (SByte*)
215 public unsafe void Constructor3_Value_Null ()
216 {
217 Assert.AreEqual (String.Empty, new String ((sbyte*) null));
218 }
219
220 [Test] // ctor (SByte*)
221 [Ignore ("invalid test")]
222 public unsafe void Constructor3_Value_Invalid ()
223 {
224 try {
225 new String ((sbyte*) (-1));
226 Assert.Fail ("#1");
227 } catch (ArgumentOutOfRangeException ex) {
228 // Pointer startIndex and length do not refer to a
229 // valid string
230 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
231 Assert.IsNull (ex.InnerException, "#3");
232 Assert.IsNotNull (ex.Message, "#4");
233 Assert.AreEqual ("ptr", ex.ParamName, "#5");
234 }
235 }
236
237 [Test] // ctor (SByte*, Int32, Int32)
238 public unsafe void Constructor7_Length_Negative ()
239 {
240 try {
241 new String ((sbyte*) null, 0, -1);
242 Assert.Fail ("#1");
243 } catch (ArgumentOutOfRangeException ex) {
244 // Length cannot be less than zero
245 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
246 Assert.IsNull (ex.InnerException, "#3");
247 Assert.IsNotNull (ex.Message, "#4");
248 Assert.AreEqual ("length", ex.ParamName, "#5");
249 }
250 }
251
252 [Test] // ctor (SByte*, Int32, Int32)
253 public unsafe void Constructor7_StartIndex_Negative ()
254 {
255 try {
256 new String ((sbyte*) null, -1, 0);
257 Assert.Fail ("#1");
258 } catch (ArgumentOutOfRangeException ex) {
259 // StartIndex cannot be less than zero
260 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
261 Assert.IsNull (ex.InnerException, "#3");
262 Assert.IsNotNull (ex.Message, "#4");
263 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
264 }
265 }
266
267 [Test]
268 public unsafe void Constructor7_StartIndex_Overflow ()
269 {
270 try {
271 new String ((sbyte*) (-1), 1, 0);
272 Assert.Fail ("#A1");
273 } catch (ArgumentOutOfRangeException ex) {
274 // Pointer startIndex and length do not refer to a
275 // valid string
276 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
277 Assert.IsNull (ex.InnerException, "#A3");
278 Assert.IsNotNull (ex.Message, "#A4");
279 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
280 }
281
282 try {
283 new String ((sbyte*) (-1), 1, 1);
284 Assert.Fail ("#B1");
285 } catch (ArgumentOutOfRangeException ex) {
286 // Pointer startIndex and length do not refer to a
287 // valid string
288 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
289 Assert.IsNull (ex.InnerException, "#B3");
290 Assert.IsNotNull (ex.Message, "#B4");
291 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
292 }
293 }
294
295 [Test] // ctor (SByte*, Int32, Int32)
296 [Ignore ("invalid test")]
297 public unsafe void Constructor7_Value_Invalid ()
298 {
299 try {
300 new String ((sbyte*) (-1), 0, 1);
301 Assert.Fail ("#1");
302 } catch (ArgumentOutOfRangeException ex) {
303 // Pointer startIndex and length do not refer to a
304 // valid string
305 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
306 Assert.IsNull (ex.InnerException, "#3");
307 Assert.IsNotNull (ex.Message, "#4");
308 Assert.AreEqual ("ptr", ex.ParamName, "#5");
309 }
310 }
311
312 [Test] // ctor (SByte*, Int32, Int32)
313 public unsafe void Constructor7_Value_Null ()
314 {
315 try {
316 new String ((sbyte*) null, 0, 0);
317 Assert.Fail ("#A1");
318 } catch (ArgumentNullException ex) {
319 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
320 Assert.IsNull (ex.InnerException, "#A3");
321 Assert.IsNotNull (ex.Message, "#A4");
322 Assert.AreEqual ("value", ex.ParamName, "#A5");
323 }
324
325 try {
326 new String ((sbyte*) null, 0, 1);
327 Assert.Fail ("#B1");
328 } catch (ArgumentNullException ex) {
329 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
330 Assert.IsNull (ex.InnerException, "#B3");
331 Assert.IsNotNull (ex.Message, "#B4");
332 Assert.AreEqual ("value", ex.ParamName, "#B5");
333 }
334
335 try {
336 new String ((sbyte*) null, 1, 0);
337 Assert.Fail ("#C1");
338 } catch (ArgumentNullException ex) {
339 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
340 Assert.IsNull (ex.InnerException, "#C3");
341 Assert.IsNotNull (ex.Message, "#C4");
342 Assert.AreEqual ("value", ex.ParamName, "#C5");
343 }
344 }
345
346 [Test] // ctor (SByte*, Int32, Int32, Encoding)
347 public unsafe void Constructor8_Length_Negative ()
348 {
349 try {
350 new String ((sbyte*) null, 0, -1, null);
351 Assert.Fail ("#A1");
352 } catch (ArgumentOutOfRangeException ex) {
353 // Length cannot be less than zero
354 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
355 Assert.IsNull (ex.InnerException, "#A3");
356 Assert.IsNotNull (ex.Message, "#A4");
357 Assert.AreEqual ("length", ex.ParamName, "#A5");
358 }
359
360 try {
361 new String ((sbyte*) null, 0, -1, Encoding.Default);
362 Assert.Fail ("#B1");
363 } catch (ArgumentOutOfRangeException ex) {
364 // Non-negative number required
365 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
366 Assert.IsNull (ex.InnerException, "#B3");
367 Assert.IsNotNull (ex.Message, "#B4");
368 Assert.AreEqual ("length", ex.ParamName, "#B5");
369 }
370 }
371
372 [Test] // ctor (SByte*, Int32, Int32, Encoding)
373 public unsafe void Constructor8_StartIndex_Negative ()
374 {
375 try {
376 new String ((sbyte*) null, -1, 0, null);
377 Assert.Fail ("#A1");
378 } catch (ArgumentOutOfRangeException ex) {
379 // StartIndex cannot be less than zero
380 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
381 Assert.IsNull (ex.InnerException, "#A3");
382 Assert.IsNotNull (ex.Message, "#A4");
383 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
384 }
385
386 try {
387 new String ((sbyte*) null, -1, 0, Encoding.Default);
388 Assert.Fail ("#B1");
389 } catch (ArgumentOutOfRangeException ex) {
390 // StartIndex cannot be less than zero
391 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
392 Assert.IsNull (ex.InnerException, "#B3");
393 Assert.IsNotNull (ex.Message, "#B4");
394 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
395 }
396 }
397
398 [Test]
399 public unsafe void Constructor8_StartIndex_Overflow ()
400 {
401 try {
402 new String ((sbyte*) (-1), 1, 0, null);
403 Assert.Fail ("#A1");
404 } catch (ArgumentOutOfRangeException ex) {
405 // Pointer startIndex and length do not refer to a
406 // valid string
407 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
408 Assert.IsNull (ex.InnerException, "#A3");
409 Assert.IsNotNull (ex.Message, "#A4");
410 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
411 }
412
413 try {
414 new String ((sbyte*) (-1), 1, 1, null);
415 Assert.Fail ("#B1");
416 } catch (ArgumentOutOfRangeException ex) {
417 // Pointer startIndex and length do not refer to a
418 // valid string
419 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
420 Assert.IsNull (ex.InnerException, "#B3");
421 Assert.IsNotNull (ex.Message, "#B4");
422 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
423 }
424
425 try {
426 new String ((sbyte*) (-1), 1, 0, Encoding.Default);
427 Assert.Fail ("#C1");
428 } catch (ArgumentOutOfRangeException ex) {
429 // Pointer startIndex and length do not refer to a
430 // valid string
431 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
432 Assert.IsNull (ex.InnerException, "#C3");
433 Assert.IsNotNull (ex.Message, "#C4");
434 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
435 }
436
437 try {
438 new String ((sbyte*) (-1), 1, 1, Encoding.Default);
439 Assert.Fail ("#D1");
440 } catch (ArgumentOutOfRangeException ex) {
441 // Pointer startIndex and length do not refer to a
442 // valid string
443 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
444 Assert.IsNull (ex.InnerException, "#D3");
445 Assert.IsNotNull (ex.Message, "#D4");
446 Assert.AreEqual ("startIndex", ex.ParamName, "#D5");
447 }
448 }
449
450 [Test] // ctor (SByte*, Int32, Int32, Encoding)
451 [Ignore ("invalid test")]
452 public unsafe void Constructor8_Value_Invalid ()
453 {
454 try {
455 new String ((sbyte*) (-1), 0, 1, null);
456 Assert.Fail ("#1");
457 } catch (ArgumentOutOfRangeException ex) {
458 // Pointer startIndex and length do not refer to a
459 // valid string
460 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
461 Assert.IsNull (ex.InnerException, "#3");
462 Assert.IsNotNull (ex.Message, "#4");
463 Assert.AreEqual ("ptr", ex.ParamName, "#5");
464 }
465 }
466
467 [Test]
468 [Ignore ("Runtime throws NullReferenceException instead of AccessViolationException")]
469 [ExpectedException (typeof (AccessViolationException))]
470 public unsafe void Constructor8_Value_Invalid2 ()
471 {
472 new String ((sbyte*) (-1), 0, 1, Encoding.Default);
473 }
474
475 [Test] // ctor (SByte*, Int32, Int32, Encoding)
476 public unsafe void Constructor8_Value_Null ()
477 {
478 try {
479 new String ((sbyte*) null, 0, 0, null);
480 Assert.Fail ("#A1");
481 } catch (ArgumentNullException ex) {
482 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
483 Assert.IsNull (ex.InnerException, "#A3");
484 Assert.IsNotNull (ex.Message, "#A4");
485 Assert.AreEqual ("value", ex.ParamName, "#A5");
486 }
487
488 try {
489 new String ((sbyte*) null, 0, 1, null);
490 Assert.Fail ("#B1");
491 } catch (ArgumentNullException ex) {
492 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
493 Assert.IsNull (ex.InnerException, "#B3");
494 Assert.IsNotNull (ex.Message, "#B4");
495 Assert.AreEqual ("value", ex.ParamName, "#B5");
496 }
497
498 try {
499 new String ((sbyte*) null, 1, 0, null);
500 Assert.Fail ("#C1");
501 } catch (ArgumentNullException ex) {
502 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
503 Assert.IsNull (ex.InnerException, "#C3");
504 Assert.IsNotNull (ex.Message, "#C4");
505 Assert.AreEqual ("value", ex.ParamName, "#C5");
506 }
507
508 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0, Encoding.Default), "#D");
509
510 try {
511 new String ((sbyte*) null, 0, 1, Encoding.Default);
512 Assert.Fail ("#E1");
513 } catch (ArgumentOutOfRangeException ex) {
514 // Pointer startIndex and length do not refer to a
515 // valid string
516 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2");
517 Assert.IsNull (ex.InnerException, "#E3");
518 Assert.IsNotNull (ex.Message, "#E4");
519 //Assert.AreEqual ("value", ex.ParamName, "#E5");
520 }
521
522 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0, Encoding.Default), "#F");
523 }
524 [Test]
525 public void Length ()
526 {
527 string str = "test string";
528
529 Assert.AreEqual (11, str.Length, "wrong length");
530 }
531
532 [Test]
533 public void Clone ()
534 {
535 string s1 = "oRiGiNal";
536 Assert.AreEqual (s1, s1.Clone (), "#A1");
537 Assert.AreSame (s1, s1.Clone (), "#A2");
538
539 string s2 = new DateTime (2000, 6, 3).ToString ();
540 Assert.AreEqual (s2, s2.Clone (), "#B1");
541 Assert.AreSame (s2, s2.Clone (), "#B2");
542 }
543
544 [Test] // bug #316666
545 public void CompareNotWorking ()
546 {
547 Assert.AreEqual (String.Compare ("A", "a"), 1, "A03");
548 Assert.AreEqual (String.Compare ("a", "A"), -1, "A04");
549 }
550
551 [Test]
552 public void CompareNotWorking2 ()
553 {
554 string needle = "ab";
555 string haystack = "abbcbacab";
556 Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2, false), "basic substring check #9");
557 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
558 if (i != 7) {
559 Assert.AreEqual (-1, String.Compare(needle, 0, haystack, i, 2, false), "loop substring check #8/" + i);
560 }
561 }
562 }
563
564 [Test]
565 public void Compare ()
566 {
567 string lesser = "abc";
568 string medium = "abcd";
569 string greater = "xyz";
570 string caps = "ABC";
571
572 Assert.AreEqual (0, String.Compare (null, null));
573 Assert.AreEqual (1, String.Compare (lesser, null));
574
575 Assert.IsTrue (String.Compare (lesser, greater) < 0);
576 Assert.IsTrue (String.Compare (greater, lesser) > 0);
577 Assert.IsTrue (String.Compare (lesser, lesser) == 0);
578 Assert.IsTrue (String.Compare (lesser, medium) < 0);
579
580 Assert.IsTrue (String.Compare (lesser, caps, true) == 0);
581 Assert.IsTrue (String.Compare (lesser, caps, false) != 0);
582 Assert.AreEqual (String.Compare ("a", "b"), -1, "A01");
583 Assert.AreEqual (String.Compare ("b", "a"), 1, "A02");
584
585
586 // TODO - test with CultureInfo
587
588 string needle = "ab";
589 string haystack = "abbcbacab";
590 Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2), "basic substring check #1");
591 Assert.AreEqual (-1, String.Compare(needle, 0, haystack, 0, 3), "basic substring check #2");
592 Assert.AreEqual (0, String.Compare("ab", 0, "ab", 0, 2), "basic substring check #3");
593 Assert.AreEqual (0, String.Compare("ab", 0, "ab", 0, 3), "basic substring check #4");
594 Assert.AreEqual (0, String.Compare("abc", 0, "ab", 0, 2), "basic substring check #5");
595 Assert.AreEqual (1, String.Compare("abc", 0, "ab", 0, 5), "basic substring check #6");
596 Assert.AreEqual (-1, String.Compare("ab", 0, "abc", 0, 5), "basic substring check #7");
597
598 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
599 if (i != 7) {
600 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2) != 0, "loop substring check #1/" + i);
601 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 3) != 0, "loop substring check #2/" + i);
602 } else {
603 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2), "loop substring check #3/" + i);
604 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 3), "loop substring check #4/" + i);
605 }
606 }
607
608 needle = "AB";
609 Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2, true), "basic substring check #8");
610 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
611 if (i != 7) {
612 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2, true) != 0, "loop substring check #5/" + i);
613 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2, false) != 0, "loop substring check #6/" + i);
614 } else {
615 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2, true), "loop substring check #7/" + i);
616 }
617 }
618
619 Assert.AreEqual (0, String.Compare (needle, 0, haystack, 0, 0), "Compare with 0 length");
620
621 // TODO - extended format call with CultureInfo
622 }
623
624 [Test]
625 public void CompareOrdinal ()
626 {
627 string lesser = "abc";
628 string medium = "abcd";
629 string greater = "xyz";
630
631 Assert.AreEqual (0, String.CompareOrdinal (null, null));
632 Assert.AreEqual (1, String.CompareOrdinal (lesser, null));
633
634 Assert.IsTrue (String.CompareOrdinal (lesser, greater) < 0, "#1");
635 Assert.IsTrue (String.CompareOrdinal (greater, lesser) > 0, "#2");
636 Assert.IsTrue (String.CompareOrdinal (lesser, lesser) == 0, "#3");
637 Assert.IsTrue (String.CompareOrdinal (lesser, medium) < 0, "#4");
638
639 string needle = "ab";
640 string haystack = "abbcbacab";
641 Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, 0, 2), "basic substring check");
642 Assert.AreEqual (-1, String.CompareOrdinal(needle, 0, haystack, 0, 3), "basic substring miss");
643 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
644 if (i != 7) {
645 Assert.IsTrue (String.CompareOrdinal(needle, 0, haystack, i, 2) != 0, "loop substring check " + i);
646 Assert.IsTrue (String.CompareOrdinal(needle, 0, haystack, i, 3) != 0, "loop substring check " + i);
647 } else {
648 Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, i, 2), "loop substring check " + i);
649 Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, i, 3), "loop substring check " + i);
650 }
651 }
652 }
653
654 [Test]
655 public void CompareOrdinalWithOffset ()
656 {
657 string ab1 = "ab";
658 string ab2 = "a" + new string ('b', 1);
659
660 Assert.IsTrue (string.CompareOrdinal (ab1, 0, ab1, 1, 1) < 0, "#1");
661 Assert.IsTrue (string.CompareOrdinal (ab2, 0, ab1, 1, 1) < 0, "#2");
662 }
663
664 [Test]
665 public void CompareOrdinalSubstringWithNull ()
666 {
667 string lesser = "abc";
668 string greater = "xyz";
669
670 Assert.AreEqual (0, string.CompareOrdinal (null, 0, null, 0, 0), "substring both null");
671 Assert.AreEqual (-1, string.CompareOrdinal (null, 0, greater, 0, 0), "substring strA null");
672 Assert.AreEqual (-1, string.CompareOrdinal (null, 4, greater, 0, 0), "substring strA null; indexA greater than strA.Length");
673 Assert.AreEqual (-1, string.CompareOrdinal (null, 0, greater, 4, 0), "substring strA null; indexB greater than strB.Length");
674 Assert.AreEqual (-1, string.CompareOrdinal (null, -1, greater, -1, -1), "substring strA null; indexA, indexB, length negative");
675 Assert.AreEqual (1, string.CompareOrdinal (lesser, 0, null, 0, 0), "substring strB null");
676 Assert.AreEqual (1, string.CompareOrdinal (lesser, 4, null, 0, 0), "substring strB null; indexA greater than strA.Length");
677 Assert.AreEqual (1, string.CompareOrdinal (lesser, 0, null, 4, 0), "substring strB null; indexB greater than strB.Length");
678 Assert.AreEqual (1, string.CompareOrdinal (lesser, -1, null, -1, -1), "substring strB null; indexA, indexB, length negative");
679 }
680
681 [Test]
682 public void CompareTo ()
683 {
684 string lower = "abc";
685 string greater = "xyz";
686 string lesser = "abc";
687
688 Assert.IsTrue (lower.CompareTo (greater) < 0);
689 Assert.IsTrue (lower.CompareTo (lower) == 0);
690 Assert.IsTrue (greater.CompareTo (lesser) > 0);
691 }
692
693 class WeirdToString
694 {
695 public override string ToString ()
696 {
697 return null;
698 }
699 }
700
701 [Test]
702 public void Concat ()
703 {
704 string string1 = "string1";
705 string string2 = "string2";
706 string concat = "string1string2";
707
708 Assert.IsTrue (String.Concat (string1, string2) == concat);
709
710 Assert.AreEqual (string1, String.Concat (string1, null));
711 Assert.AreEqual (string1, String.Concat (null, string1));
712 Assert.AreEqual (string.Empty, String.Concat (null, null));
713
714 WeirdToString wts = new WeirdToString ();
715 Assert.AreEqual (string1, String.Concat (string1, wts));
716 Assert.AreEqual (string1, String.Concat (wts, string1));
717 Assert.AreEqual (string.Empty, String.Concat (wts, wts));
718 string [] allstr = new string []{ string1, null, string2, concat };
719 object [] allobj = new object []{ string1, null, string2, concat };
720 string astr = String.Concat (allstr);
721 Assert.AreEqual ("string1string2string1string2", astr);
722 string ostr = String.Concat (allobj);
723 Assert.AreEqual (astr, ostr);
724 }
725
726 [Test]
727 public void Copy ()
728 {
729 string s1 = "original";
730 string s2 = String.Copy(s1);
731 Assert.AreEqual (s1, s2, "#1");
732 Assert.IsTrue (!object.ReferenceEquals (s1, s2), "#2");
733 }
734
735 [Test]
736 public void Copy_Str_Null ()
737 {
738 try {
739 String.Copy ((string) null);
740 Assert.Fail ("#1");
741 } catch (ArgumentNullException ex) {
742 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
743 Assert.IsNull (ex.InnerException, "#3");
744 Assert.IsNotNull (ex.Message, "#4");
745 Assert.AreEqual ("str", ex.ParamName, "#5");
746 }
747 }
748
749 [Test]
750 public void CopyTo ()
751 {
752 string s1 = "original";
753 char[] c1 = new char[s1.Length];
754 string s2 = new String(c1);
755 Assert.IsTrue (!s1.Equals(s2), "#1");
756 for (int i = 0; i < s1.Length; i++) {
757 s1.CopyTo(i, c1, i, 1);
758 }
759 s2 = new String(c1);
760 Assert.AreEqual (s1, s2, "#2");
761 }
762
763 [Test]
764 public void CopyTo_Count_Negative ()
765 {
766 char [] dest = new char [4];
767 try {
768 "Mono".CopyTo (0, dest, 0, -1);
769 Assert.Fail ("#1");
770 } catch (ArgumentOutOfRangeException ex) {
771 // Count cannot be less than zero
772 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
773 Assert.IsNull (ex.InnerException, "#3");
774 Assert.IsNotNull (ex.Message, "#4");
775 Assert.AreEqual ("count", ex.ParamName, "#5");
776 }
777 }
778
779 [Test]
780 public void CopyTo_Count_Overflow ()
781 {
782 char [] dest = new char [4];
783 try {
784 "Mono".CopyTo (0, dest, 0, Int32.MaxValue);
785 Assert.Fail ("#1");
786 } catch (ArgumentOutOfRangeException ex) {
787 // Index and count must refer to a location within the
788 // string
789 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
790 Assert.IsNull (ex.InnerException, "#3");
791 Assert.IsNotNull (ex.Message, "#4");
792 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
793 }
794 }
795
796 [Test]
797 public void CopyTo_Destination_Null ()
798 {
799 string s = "original";
800
801 try {
802 s.CopyTo (0, (char []) null, 0, s.Length);
803 Assert.Fail ("#1");
804 } catch (ArgumentNullException ex) {
805 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
806 Assert.IsNull (ex.InnerException, "#3");
807 Assert.IsNotNull (ex.Message, "#4");
808 Assert.AreEqual ("destination", ex.ParamName, "#5");
809 }
810 }
811
812 [Test]
813 public void CopyTo_DestinationIndex_Negative ()
814 {
815 char [] dest = new char [4];
816 try {
817 "Mono".CopyTo (0, dest, -1, 4);
818 Assert.Fail ("#1");
819 } catch (ArgumentOutOfRangeException ex) {
820 // Index and count must refer to a location within the
821 // string
822 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
823 Assert.IsNull (ex.InnerException, "#3");
824 Assert.IsNotNull (ex.Message, "#4");
825 Assert.AreEqual ("destinationIndex", ex.ParamName, "#5");
826 }
827 }
828
829 [Test]
830 public void CopyTo_DestinationIndex_Overflow ()
831 {
832 char [] dest = new char [4];
833 try {
834 "Mono".CopyTo (0, dest, Int32.MaxValue, 4);
835 Assert.Fail ("#1");
836 } catch (ArgumentOutOfRangeException ex) {
837 // Index and count must refer to a location within the
838 // string
839 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
840 Assert.IsNull (ex.InnerException, "#3");
841 Assert.IsNotNull (ex.Message, "#4");
842 Assert.AreEqual ("destinationIndex", ex.ParamName, "#5");
843 }
844 }
845
846 [Test]
847 public void CopyTo_SourceIndex_Negative ()
848 {
849 char [] dest = new char [4];
850 try {
851 "Mono".CopyTo (-1, dest, 0, 4);
852 Assert.Fail ("#1");
853 } catch (ArgumentOutOfRangeException ex) {
854 // Index was out of range. Must be non-negative and
855 // less than the size of the collection
856 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
857 Assert.IsNull (ex.InnerException, "#3");
858 Assert.IsNotNull (ex.Message, "#4");
859 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
860 }
861 }
862
863 [Test]
864 public void CopyTo_SourceIndex_Overflow ()
865 {
866 char[] dest = new char [4];
867 try {
868 "Mono".CopyTo (Int32.MaxValue, dest, 0, 4);
869 Assert.Fail ("#1");
870 } catch (ArgumentOutOfRangeException ex) {
871 // Index and count must refer to a location within the
872 // string
873 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
874 Assert.IsNull (ex.InnerException, "#3");
875 Assert.IsNotNull (ex.Message, "#4");
876 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
877 }
878 }
879
880 [Test] // EndsWith (String)
881 public void EndsWith1 ()
882 {
883 string s;
884
885 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
886 s = "AbC";
887
888 Assert.IsTrue (s.EndsWith ("bC"), "#A1");
889 Assert.IsTrue (!s.EndsWith ("bc"), "#A1");
890 Assert.IsTrue (!s.EndsWith ("dc"), "#A2");
891 Assert.IsTrue (!s.EndsWith ("LAbC"), "#A3");
892 Assert.IsTrue (s.EndsWith (string.Empty), "#A4");
893 Assert.IsTrue (!s.EndsWith ("Ab"), "#A5");
894 Assert.IsTrue (!s.EndsWith ("Abc"), "#A6");
895 Assert.IsTrue (s.EndsWith ("AbC"), "#A7");
896
897 s = "Tai";
898
899 Assert.IsTrue (s.EndsWith ("ai"), "#B1");
900 Assert.IsTrue (!s.EndsWith ("AI"), "#B2");
901 Assert.IsTrue (!s.EndsWith ("LTai"), "#B3");
902 Assert.IsTrue (s.EndsWith (string.Empty), "#B4");
903 Assert.IsTrue (!s.EndsWith ("Ta"), "#B5");
904 Assert.IsTrue (!s.EndsWith ("tai"), "#B6");
905 Assert.IsTrue (s.EndsWith ("Tai"), "#B7");
906
907 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
908
909 Assert.IsTrue (s.EndsWith ("ai"), "#C1");
910 Assert.IsTrue (!s.EndsWith ("AI"), "#C2");
911 Assert.IsTrue (!s.EndsWith ("LTai"), "#C3");
912 Assert.IsTrue (s.EndsWith (string.Empty), "#C4");
913 Assert.IsTrue (!s.EndsWith ("Ta"), "#C5");
914 Assert.IsTrue (!s.EndsWith ("tai"), "#C6");
915 Assert.IsTrue (s.EndsWith ("Tai"), "#C7");
916 }
917
918 [Test] // EndsWith (String)
919 public void EndsWith1_Value_Null ()
920 {
921 try {
922 "ABC".EndsWith ((string) null);
923 Assert.Fail ("#1");
924 } catch (ArgumentNullException ex) {
925 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
926 Assert.IsNull (ex.InnerException, "#3");
927 Assert.IsNotNull (ex.Message, "#4");
928 Assert.AreEqual ("value", ex.ParamName, "#5");
929 }
930 }
931
932 [Test] // EndsWith (String, StringComparison)
933 public void EndsWith2_ComparisonType_Invalid ()
934 {
935 try {
936 "ABC".EndsWith ("C", (StringComparison) 80);
937 Assert.Fail ("#1");
938 } catch (ArgumentException ex) {
939 // The string comparison type passed in is currently
940 // not supported
941 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
942 Assert.IsNull (ex.InnerException, "#3");
943 Assert.IsNotNull (ex.Message, "#4");
944 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
945 }
946 }
947
948 [Test] // EndsWith (String, StringComparison)
949 public void EndsWith2_Value_Null ()
950 {
951 try {
952 "ABC".EndsWith ((string) null, StringComparison.CurrentCulture);
953 Assert.Fail ("#1");
954 } catch (ArgumentNullException ex) {
955 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
956 Assert.IsNull (ex.InnerException, "#3");
957 Assert.IsNotNull (ex.Message, "#4");
958 Assert.AreEqual ("value", ex.ParamName, "#5");
959 }
960 }
961
962 [Test] // EndsWith (String, Boolean, CultureInfo)
963 public void EndsWith3 ()
964 {
965 string s;
966 bool ignorecase;
967 CultureInfo culture;
968
969 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
970 s = "AbC";
971 culture = null;
972
973 ignorecase = false;
974 Assert.IsTrue (!s.EndsWith ("bc", ignorecase, culture), "#A1");
975 Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#A2");
976 Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#A3");
977 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#A4");
978 Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#A5");
979 Assert.IsTrue (!s.EndsWith ("Abc", ignorecase, culture), "#A6");
980 Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#A7");
981
982 ignorecase = true;
983 Assert.IsTrue (s.EndsWith ("bc", ignorecase, culture), "#B1");
984 Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#B2");
985 Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#B3");
986 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#B4");
987 Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#B5");
988 Assert.IsTrue (s.EndsWith ("Abc", ignorecase, culture), "#B6");
989 Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#B7");
990
991 s = "Tai";
992 culture = null;
993
994 ignorecase = false;
995 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#C1");
996 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#C2");
997 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#C3");
998 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#C4");
999 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#C5");
1000 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#C6");
1001 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#C7");
1002
1003 ignorecase = true;
1004 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#D1");
1005 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#D2");
1006 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#D3");
1007 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#D4");
1008 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#D5");
1009 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#D6");
1010 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#D7");
1011
1012 s = "Tai";
1013 culture = new CultureInfo ("en-US");
1014
1015 ignorecase = false;
1016 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#E1");
1017 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#E2");
1018 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#E3");
1019 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#E4");
1020 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#E5");
1021 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#E6");
1022 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#E7");
1023
1024 ignorecase = true;
1025 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#F1");
1026 Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#F2");
1027 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#F3");
1028 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#F4");
1029 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#F5");
1030 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#F6");
1031 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#F7");
1032
1033 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1034 culture = null;
1035
1036 ignorecase = false;
1037 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#G1");
1038 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#G2");
1039 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#G3");
1040 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#G4");
1041 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#G5");
1042 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#G6");
1043 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#G7");
1044
1045 ignorecase = true;
1046 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#H1");
1047 Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#H2");
1048 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#H3");
1049 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#H4");
1050 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#H5");
1051 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#H6");
1052 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#H7");
1053 }
1054
1055 [Test] // EndsWith (String, Boolean, CultureInfo)
1056 public void EndsWith3_Value_Null ()
1057 {
1058 try {
1059 "ABC".EndsWith ((string) null, true, null);
1060 Assert.Fail ("#1");
1061 } catch (ArgumentNullException ex) {
1062 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1063 Assert.IsNull (ex.InnerException, "#3");
1064 Assert.IsNotNull (ex.Message, "#4");
1065 Assert.AreEqual ("value", ex.ParamName, "#5");
1066 }
1067 }
1068
1069 [Test]
1070 public void TestEquals ()
1071 {
1072 string s1 = "original";
1073 string yes = "original";
1074 object y = yes;
1075 string no = "copy";
1076 string s1s1 = s1 + s1;
1077
1078 Assert.IsTrue (!s1.Equals (null), "No match for null");
1079 Assert.IsTrue (s1.Equals (y), "Should match object");
1080 Assert.IsTrue (s1.Equals (yes), "Should match");
1081 Assert.IsTrue (!s1.Equals (no), "Shouldn't match");
1082
1083 Assert.IsTrue (String.Equals (null, null), "Static nulls should match");
1084 Assert.IsTrue (String.Equals (s1, yes), "Should match");
1085 Assert.IsTrue (!String.Equals (s1, no), "Shouldn't match");
1086
1087 Assert.AreEqual (false, s1s1.Equals (y), "Equals (object)");
1088 }
1089
1090 [Test]
1091 public void TestFormat ()
1092 {
1093 Assert.AreEqual (string.Empty, String.Format (string.Empty, 0), "Empty format string.");
1094 Assert.AreEqual ("100", String.Format ("{0}", 100), "Single argument.");
1095 Assert.AreEqual ("X 37X", String.Format ("X{0,5}X", 37), "Single argument, right justified.");
1096 Assert.AreEqual ("X37 X", String.Format ("X{0,-5}X", 37), "Single argument, left justified.");
1097 Assert.AreEqual (" 7d", String.Format ("{0, 4:x}", 125), "Whitespace in specifier");
1098 Assert.AreEqual ("The 3 wise men.", String.Format ("The {0} wise {1}.", 3, "men"), "Two arguments.");
1099 Assert.AreEqual ("do re me fa so.", String.Format ("{0} re {1} fa {2}.", "do", "me", "so"), "Three arguments.");
1100 Assert.AreEqual ("###00c0ffee#", String.Format ("###{0:x8}#", 0xc0ffee), "Formatted argument.");
1101 Assert.AreEqual ("# 033#", String.Format ("#{0,5:x3}#", 0x33), "Formatted argument, right justified.");
1102 Assert.AreEqual ("#033 #", String.Format ("#{0,-5:x3}#", 0x33), "Formatted argument, left justified.");
1103 Assert.AreEqual ("typedef struct _MonoObject { ... } MonoObject;", String.Format ("typedef struct _{0} {{ ... }} MonoObject;", "MonoObject"), "Escaped bracket");
1104 Assert.AreEqual ("Could not find file \"a/b\"", String.Format ("Could not find file \"{0}\"", "a/b"), "With Slash");
1105 Assert.AreEqual ("Could not find file \"a\\b\"", String.Format ("Could not find file \"{0}\"", "a\\b"), "With BackSlash");
1106 }
1107
1108 [Test] // Format (String, Object)
1109 public void Format1_Format_Null ()
1110 {
1111 try {
1112 String.Format (null, 1);
1113 Assert.Fail ("#1");
1114 } catch (ArgumentNullException ex) {
1115 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1116 Assert.IsNull (ex.InnerException, "#3");
1117 Assert.IsNotNull (ex.Message, "#4");
1118 Assert.AreEqual ("format", ex.ParamName, "#5");
1119 }
1120 }
1121
1122 [Test] // Format (String, Object [])
1123 public void Format2_Format_Null ()
1124 {
1125 try {
1126 String.Format (null, new object [] { 2 });
1127 Assert.Fail ("#1");
1128 } catch (ArgumentNullException ex) {
1129 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1130 Assert.IsNull (ex.InnerException, "#3");
1131 Assert.IsNotNull (ex.Message, "#4");
1132 Assert.AreEqual ("format", ex.ParamName, "#5");
1133 }
1134 }
1135
1136 [Test] // Format (String, Object [])
1137 public void Format2_Args_Null ()
1138 {
1139 try {
1140 String.Format ("text", (object []) null);
1141 Assert.Fail ("#1");
1142 } catch (ArgumentNullException ex) {
1143 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1144 Assert.IsNull (ex.InnerException, "#3");
1145 Assert.IsNotNull (ex.Message, "#4");
1146 Assert.AreEqual ("args", ex.ParamName, "#5");
1147 }
1148 }
1149
1150 [Test] // Format (IFormatProvider, String, Object [])
1151 public void Format3_Format_Null ()
1152 {
1153 try {
1154 String.Format (CultureInfo.InvariantCulture, null,
1155 new object [] { 3 });
1156 Assert.Fail ("#1");
1157 } catch (ArgumentNullException ex) {
1158 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1159 Assert.IsNull (ex.InnerException, "#3");
1160 Assert.IsNotNull (ex.Message, "#4");
1161 Assert.AreEqual ("format", ex.ParamName, "#5");
1162 }
1163 }
1164
1165 [Test] // Format (IFormatProvider, String, Object [])
1166 public void Format3_Args_Null ()
1167 {
1168 try {
1169 String.Format (CultureInfo.InvariantCulture, "text",
1170 (object []) null);
1171 Assert.Fail ("#1");
1172 } catch (ArgumentNullException ex) {
1173 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1174 Assert.IsNull (ex.InnerException, "#3");
1175 Assert.IsNotNull (ex.Message, "#4");
1176 Assert.AreEqual ("args", ex.ParamName, "#5");
1177 }
1178 }
1179
1180 [Test] // Format (String, Object, Object)
1181 public void Format4_Format_Null ()
1182 {
1183 try {
1184 String.Format (null, 4, 5);
1185 Assert.Fail ("#1");
1186 } catch (ArgumentNullException ex) {
1187 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1188 Assert.IsNull (ex.InnerException, "#3");
1189 Assert.IsNotNull (ex.Message, "#4");
1190 Assert.AreEqual ("format", ex.ParamName, "#5");
1191 }
1192 }
1193
1194 [Test] // Format (String, Object, Object, Object)
1195 public void Format5_Format_Null ()
1196 {
1197 try {
1198 String.Format (null, 4, 5, 6);
1199 Assert.Fail ("#1");
1200 } catch (ArgumentNullException ex) {
1201 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1202 Assert.IsNull (ex.InnerException, "#3");
1203 Assert.IsNotNull (ex.Message, "#4");
1204 Assert.AreEqual ("format", ex.ParamName, "#5");
1205 }
1206 }
1207
1208 [Test]
1209 public void Format ()
1210 {
1211 var s = String.Format (new NullFormatter (), "{0:}", "test");
1212 Assert.AreEqual ("test", s);
1213 }
1214
1215 [Test]
1216 public void Format_Arg_ToNullStringer ()
1217 {
1218 var s = String.Format ("{0}", new ToNullStringer ());
1219 Assert.AreEqual ("", s);
1220 }
1221
1222 [Test]
1223 public void TestGetEnumerator ()
1224 {
1225 string s1 = "original";
1226 char[] c1 = new char[s1.Length];
1227 string s2 = new String(c1);
1228 Assert.IsTrue (!s1.Equals(s2), "pre-enumerated string should not match");
1229 CharEnumerator en = s1.GetEnumerator();
1230 Assert.IsNotNull (en, "null enumerator");
1231
1232 for (int i = 0; i < s1.Length; i++) {
1233 en.MoveNext();
1234 c1[i] = en.Current;
1235 }
1236 s2 = new String(c1);
1237 Assert.AreEqual (s1, s2, "enumerated string should match");
1238 }
1239
1240 [Test]
1241 public void TestGetHashCode ()
1242 {
1243 string s1 = "original";
1244 // TODO - weak test, currently. Just verifies determinicity.
1245 Assert.AreEqual (s1.GetHashCode(), s1.GetHashCode(), "same string, same hash code");
1246 }
1247
1248 [Test]
1249 public void TestGetType ()
1250 {
1251 string s1 = "original";
1252 Assert.AreEqual ("System.String", s1.GetType().ToString(), "String type");
1253 }
1254
1255 [Test]
1256 public void TestGetTypeCode ()
1257 {
1258 string s1 = "original";
1259 Assert.IsTrue (s1.GetTypeCode().Equals(TypeCode.String));
1260 }
1261
1262 [Test]
1263 public void IndexOf ()
1264 {
1265 string s1 = "original";
1266
1267 try {
1268 s1.IndexOf ('q', s1.Length + 1);
1269 Assert.Fail ("#A1");
1270 } catch (ArgumentOutOfRangeException ex) {
1271 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1272 Assert.IsNull (ex.InnerException, "#A3");
1273 Assert.IsNotNull (ex.Message, "#A4");
1274 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
1275 }
1276
1277 try {
1278 s1.IndexOf ('q', s1.Length + 1, 1);
1279 Assert.Fail ("#B1");
1280 } catch (ArgumentOutOfRangeException ex) {
1281 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1282 Assert.IsNull (ex.InnerException, "#B3");
1283 Assert.IsNotNull (ex.Message, "#B4");
1284 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
1285 }
1286
1287 try {
1288 s1.IndexOf ("huh", s1.Length + 1);
1289 Assert.Fail ("#C1");
1290 } catch (ArgumentOutOfRangeException ex) {
1291 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1292 Assert.IsNull (ex.InnerException, "#C3");
1293 Assert.IsNotNull (ex.Message, "#C4");
1294 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
1295 }
1296
1297 Assert.AreEqual (1, s1.IndexOf('r'), "basic char index");
1298 Assert.AreEqual (2, s1.IndexOf('i'), "basic char index 2");
1299 Assert.AreEqual (-1, s1.IndexOf('q'), "basic char index - no");
1300
1301 Assert.AreEqual (1, s1.IndexOf("rig"), "basic string index");
1302 Assert.AreEqual (2, s1.IndexOf("i"), "basic string index 2");
1303 Assert.AreEqual (0, string.Empty.IndexOf(string.Empty), "basic string index 3");
1304 Assert.AreEqual (0, "ABC".IndexOf(string.Empty), "basic string index 4");
1305 Assert.AreEqual (-1, s1.IndexOf("rag"), "basic string index - no");
1306
1307 Assert.AreEqual (1, s1.IndexOf('r', 1), "stepped char index");
1308 Assert.AreEqual (2, s1.IndexOf('i', 1), "stepped char index 2");
1309 Assert.AreEqual (4, s1.IndexOf('i', 3), "stepped char index 3");
1310 Assert.AreEqual (-1, s1.IndexOf('i', 5), "stepped char index 4");
1311 Assert.AreEqual (-1, s1.IndexOf('l', s1.Length), "stepped char index 5");
1312
1313 Assert.AreEqual (1, s1.IndexOf('r', 1, 1), "stepped limited char index");
1314 Assert.AreEqual (-1, s1.IndexOf('r', 0, 1), "stepped limited char index");
1315 Assert.AreEqual (2, s1.IndexOf('i', 1, 3), "stepped limited char index");
1316 Assert.AreEqual (4, s1.IndexOf('i', 3, 3), "stepped limited char index");
1317 Assert.AreEqual (-1, s1.IndexOf('i', 5, 3), "stepped limited char index");
1318
1319 s1 = "original original";
1320 Assert.AreEqual (0, s1.IndexOf("original", 0), "stepped string index 1");
1321 Assert.AreEqual (9, s1.IndexOf("original", 1), "stepped string index 2");
1322 Assert.AreEqual (-1, s1.IndexOf("original", 10), "stepped string index 3");
1323 Assert.AreEqual (3, s1.IndexOf(string.Empty, 3), "stepped string index 4");
1324 Assert.AreEqual (1, s1.IndexOf("rig", 0, 5), "stepped limited string index 1");
1325 Assert.AreEqual (-1, s1.IndexOf("rig", 0, 3), "stepped limited string index 2");
1326 Assert.AreEqual (10, s1.IndexOf("rig", 2, 15), "stepped limited string index 3");
1327 Assert.AreEqual (-1, s1.IndexOf("rig", 2, 3), "stepped limited string index 4");
1328 Assert.AreEqual (2, s1.IndexOf(string.Empty, 2, 3), "stepped limited string index 5");
1329
1330 string s2 = "QBitArray::bitarr_data";
1331 Assert.AreEqual (9, s2.IndexOf ("::"), "bug #62160");
1332 }
1333
1334 [Test] // IndexOf (String)
1335 public void IndexOf2_Value_Null ()
1336 {
1337 try {
1338 "Mono".IndexOf ((string) null);
1339 Assert.Fail ("#1");
1340 } catch (ArgumentNullException ex) {
1341 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1342 Assert.IsNull (ex.InnerException, "#3");
1343 Assert.IsNotNull (ex.Message, "#4");
1344 Assert.AreEqual ("value", ex.ParamName, "#5");
1345 }
1346 }
1347
1348 [Test] // IndexOf (Char, Int32)
1349 public void IndexOf3 ()
1350 {
1351 string s = "testing123456";
1352
1353 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1354
1355 Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#A1");
1356 Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#A2");
1357 Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#A3");
1358 Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#A4");
1359 Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#A5");
1360 Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#A6");
1361 Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#A7");
1362 Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#A8");
1363
1364 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1365
1366 Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#B1");
1367 Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#B2");
1368 Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#B3");
1369 Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#B4");
1370 Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#B5");
1371 Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#B6");
1372 Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#B7");
1373 Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#B8");
1374 }
1375
1376 [Test] // IndexOf (String, Int32)
1377 public void IndexOf4 ()
1378 {
1379 string s = "testing123456";
1380
1381 Assert.AreEqual (-1, s.IndexOf ("IN", 3), "#1");
1382 Assert.AreEqual (4, s.IndexOf ("in", 3), "#2");
1383 Assert.AreEqual (-1, s.IndexOf ("in", 5), "#3");
1384 Assert.AreEqual (7, s.IndexOf ("1", 5), "#4");
1385 Assert.AreEqual (12, s.IndexOf ("6", 12), "#5");
1386 Assert.AreEqual (0, s.IndexOf ("testing123456", 0), "#6");
1387 Assert.AreEqual (-1, s.IndexOf ("testing123456", 1), "#7");
1388 Assert.AreEqual (5, s.IndexOf (string.Empty, 5), "#8");
1389 Assert.AreEqual (0, s.IndexOf (string.Empty, 0), "#9");
1390 }
1391
1392 [Test] // IndexOf (String, Int32)
1393 public void IndexOf4_Value_Null ()
1394 {
1395 try {
1396 "Mono".IndexOf ((string) null, 1);
1397 Assert.Fail ("#1");
1398 } catch (ArgumentNullException ex) {
1399 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1400 Assert.IsNull (ex.InnerException, "#3");
1401 Assert.IsNotNull (ex.Message, "#4");
1402 Assert.AreEqual ("value", ex.ParamName, "#5");
1403 }
1404 }
1405
1406 [Test] // IndexOf (String, StringComparison)
1407 public void IndexOf5 ()
1408 {
1409 string s = "testing123456";
1410 StringComparison comparison_type;
1411
1412 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1413
1414 comparison_type = StringComparison.CurrentCulture;
1415 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#A1");
1416 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#A2");
1417 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#A3");
1418 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#A4");
1419 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#A5");
1420 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#A6");
1421 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#A7");
1422 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#A8");
1423 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#A9");
1424
1425 comparison_type = StringComparison.CurrentCultureIgnoreCase;
1426 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#B1");
1427 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#B2");
1428 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#B3");
1429 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#B4");
1430 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#B5");
1431 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#B6");
1432 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#B7");
1433 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#B8");
1434 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#B9");
1435
1436 comparison_type = StringComparison.InvariantCulture;
1437 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#C1");
1438 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#C2");
1439 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#C3");
1440 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#C4");
1441 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#C5");
1442 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#C6");
1443 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#C7");
1444 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#C8");
1445 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#C9");
1446
1447 comparison_type = StringComparison.InvariantCultureIgnoreCase;
1448 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#D1");
1449 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#D2");
1450 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#D3");
1451 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#D4");
1452 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#D5");
1453 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#D6");
1454 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#D7");
1455 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#D8");
1456 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#D9");
1457
1458 comparison_type = StringComparison.Ordinal;
1459 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#E1");
1460 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#E2");
1461 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#E3");
1462 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#E4");
1463 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#E5");
1464 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#E6");
1465 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#E7");
1466 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#E8");
1467 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#E9");
1468
1469 comparison_type = StringComparison.OrdinalIgnoreCase;
1470 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#F1");
1471 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#F2");
1472 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#F3");
1473 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#F4");
1474 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#F5");
1475 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#F6");
1476 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#F7");
1477 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#F8");
1478 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#F9");
1479
1480 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1481
1482 comparison_type = StringComparison.CurrentCulture;
1483 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#G1");
1484 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#G2");
1485 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#G3");
1486 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#G4");
1487 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#G5");
1488 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#G6");
1489 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#G7");
1490 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#G8");
1491 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#G9");
1492
1493 comparison_type = StringComparison.CurrentCultureIgnoreCase;
1494 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#H1");
1495 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#H2");
1496 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#H3");
1497 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#H4");
1498 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#H5");
1499 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#H6");
1500 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#H7");
1501 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#H8");
1502 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#H9");
1503
1504 comparison_type = StringComparison.InvariantCulture;
1505 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#I1");
1506 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#I2");
1507 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#I3");
1508 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#I4");
1509 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#I5");
1510 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#I6");
1511 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#I7");
1512 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#I8");
1513 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#I9");
1514
1515 comparison_type = StringComparison.InvariantCultureIgnoreCase;
1516 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#J1");
1517 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#J2");
1518 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#J3");
1519 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#J4");
1520 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#J5");
1521 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#J6");
1522 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#J7");
1523 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#J8");
1524 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#J9");
1525
1526 comparison_type = StringComparison.Ordinal;
1527 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#K1");
1528 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#K2");
1529 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#K3");
1530 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#K4");
1531 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#K5");
1532 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#K6");
1533 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#K7");
1534 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#K8");
1535 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#K9");
1536
1537 comparison_type = StringComparison.OrdinalIgnoreCase;
1538 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#L1");
1539 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#L2");
1540 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#L3");
1541 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#L4");
1542 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#L5");
1543 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#L6");
1544 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#L7");
1545 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#L8");
1546 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#L9");
1547
1548 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, comparison_type), "#M");
1549 }
1550
1551 [Test] // IndexOf (String, StringComparison)
1552 public void IndexOf5_ComparisonType_Invalid ()
1553 {
1554 try {
1555 "Mono".IndexOf (string.Empty, (StringComparison) Int32.MinValue);
1556 Assert.Fail ("#1");
1557 } catch (ArgumentException ex) {
1558 // The string comparison type passed in is currently
1559 // not supported
1560 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1561 Assert.IsNull (ex.InnerException, "#3");
1562 Assert.IsNotNull (ex.Message, "#4");
1563 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
1564 }
1565 }
1566
1567 [Test] // IndexOf (String, StringComparison)
1568 public void IndexOf5_Value_Null ()
1569 {
1570 try {
1571 "Mono".IndexOf ((string) null, StringComparison.Ordinal);
1572 Assert.Fail ("#1");
1573 } catch (ArgumentNullException ex) {
1574 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1575 Assert.IsNull (ex.InnerException, "#3");
1576 Assert.IsNotNull (ex.Message, "#4");
1577 Assert.AreEqual ("value", ex.ParamName, "#5");
1578 }
1579 }
1580
1581 [Test]
1582 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1583 public void IndexOfStringComparisonOrdinalRangeException1 ()
1584 {
1585 "Mono".IndexOf ("no", 5, StringComparison.Ordinal);
1586 }
1587
1588 [Test]
1589 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1590 public void IndexOfStringComparisonOrdinalRangeException2 ()
1591 {
1592 "Mono".IndexOf ("no", 1, 5, StringComparison.Ordinal);
1593 }
1594
1595 [Test]
1596 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1597 public void IndexOfStringComparisonOrdinalIgnoreCaseRangeException1 ()
1598 {
1599 "Mono".IndexOf ("no", 5, StringComparison.OrdinalIgnoreCase);
1600 }
1601
1602 [Test]
1603 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1604 public void IndexOfStringComparisonOrdinalIgnoreCaseRangeException2 ()
1605 {
1606 "Mono".IndexOf ("no", 1, 5, StringComparison.OrdinalIgnoreCase);
1607 }
1608
1609 [Test]
1610 public void IndexOfStringComparisonCurrentCulture_Empty ()
1611 {
1612 Assert.AreEqual (1, "Mono".IndexOf ("", 1, StringComparison.CurrentCultureIgnoreCase));
1613 }
1614
1615 [Test]
1616 public void IndexOfStringComparison ()
1617 {
1618 string text = "testing123456";
1619 string text2 = "123";
1620 string text3 = "NG";
1621 string text4 = "t";
1622 Assert.AreEqual (7, text.IndexOf (text2, StringComparison.Ordinal), "#1-1");
1623 Assert.AreEqual (5, text.IndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1");
1624
1625 Assert.AreEqual (7, text.IndexOf (text2, 0, StringComparison.Ordinal), "#1-2");
1626 Assert.AreEqual (5, text.IndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-2");
1627
1628 Assert.AreEqual (7, text.IndexOf (text2, 1, StringComparison.Ordinal), "#1-3");
1629 Assert.AreEqual (5, text.IndexOf (text3, 1, StringComparison.OrdinalIgnoreCase), "#2-3");
1630
1631 Assert.AreEqual (7, text.IndexOf (text2, 6, StringComparison.Ordinal), "#1-4");
1632 Assert.AreEqual (-1, text.IndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4");
1633
1634 Assert.AreEqual (7, text.IndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5");
1635 Assert.AreEqual (-1, text.IndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5");
1636
1637 Assert.AreEqual (-1, text.IndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6");
1638 Assert.AreEqual (-1, text.IndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6");
1639
1640 Assert.AreEqual (-1, text.IndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7");
1641 Assert.AreEqual (-1, text.IndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7");
1642
1643 Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.Ordinal), "#3-1");
1644 Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2");
1645
1646 Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.Ordinal), "#4-1");
1647 Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2");
1648
1649 Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.Ordinal), "#4-1");
1650 Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.OrdinalIgnoreCase), "#4-2");
1651
1652 Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.Ordinal), "#5-1");
1653 Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.OrdinalIgnoreCase), "#5-2");
1654 }
1655
1656 [Test]
1657 public void IndexOfStringComparisonOrdinal ()
1658 {
1659 string text = "testing123456";
1660 Assert.AreEqual (10, text.IndexOf ("456", StringComparison.Ordinal), "#1");
1661 Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.Ordinal), "#2");
1662 Assert.AreEqual (0, text.IndexOf ("te", StringComparison.Ordinal), "#3");
1663 Assert.AreEqual (2, text.IndexOf ("s", StringComparison.Ordinal), "#4");
1664 Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.Ordinal), "#5");
1665 Assert.AreEqual (-1, text.IndexOf ("S", StringComparison.Ordinal), "#6");
1666 }
1667
1668 [Test]
1669 public void IndexOfStringComparisonOrdinalIgnoreCase ()
1670 {
1671 string text = "testing123456";
1672 Assert.AreEqual (10, text.IndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1");
1673 Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2");
1674 Assert.AreEqual (0, text.IndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3");
1675 Assert.AreEqual (2, text.IndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4");
1676 Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5");
1677 Assert.AreEqual (2, text.IndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6");
1678 }
1679
1680 [Test]
1681 public void IndexOfOrdinalCountSmallerThanValueString ()
1682 {
1683 Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.Ordinal), "#1");
1684 Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#2");
1685 Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.Ordinal), "#3");
1686 Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#4");
1687 }
1688
1689 [Test] // IndexOf (Char, Int32, Int32)
1690 public void IndexOf6_Count_Negative ()
1691 {
1692 try {
1693 "Mono".IndexOf ('o', 1, -1);
1694 Assert.Fail ("#1");
1695 } catch (ArgumentOutOfRangeException ex) {
1696 // Count must be positive and count must refer to a
1697 // location within the string/array/collection
1698 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1699 Assert.IsNull (ex.InnerException, "#3");
1700 Assert.IsNotNull (ex.Message, "#4");
1701 Assert.AreEqual ("count", ex.ParamName, "#5");
1702 }
1703 }
1704
1705 [Test] // IndexOf (Char, Int32, Int32)
1706 public void IndexOf6_Count_Overflow ()
1707 {
1708 try {
1709 "Mono".IndexOf ('o', 1, Int32.MaxValue);
1710 Assert.Fail ("#1");
1711 } catch (ArgumentOutOfRangeException ex) {
1712 // Count must be positive and count must refer to a
1713 // location within the string/array/collection
1714 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1715 Assert.IsNull (ex.InnerException, "#3");
1716 Assert.IsNotNull (ex.Message, "#4");
1717 Assert.AreEqual ("count", ex.ParamName, "#5");
1718 }
1719 }
1720
1721 [Test] // IndexOf (Char, Int32, Int32)
1722 public void IndexOf6_StartIndex_Negative ()
1723 {
1724 try {
1725 "Mono".IndexOf ('o', -1, 1);
1726 Assert.Fail ("#1");
1727 } catch (ArgumentOutOfRangeException ex) {
1728 // Index was out of range. Must be non-negative and
1729 // less than the size of the collection
1730 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1731 Assert.IsNull (ex.InnerException, "#3");
1732 Assert.IsNotNull (ex.Message, "#4");
1733 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1734 }
1735 }
1736
1737 [Test] // IndexOf (Char, Int32, Int32)
1738 public void IndexOf6_StartIndex_Overflow ()
1739 {
1740 string s = "testing123456";
1741
1742 try {
1743 s.IndexOf ('o', s.Length + 1, 1);
1744 Assert.Fail ("#1");
1745 } catch (ArgumentOutOfRangeException ex) {
1746 // Index was out of range. Must be non-negative and
1747 // less than the size of the collection
1748 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1749 Assert.IsNull (ex.InnerException, "#3");
1750 Assert.IsNotNull (ex.Message, "#4");
1751 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1752 }
1753 }
1754
1755 [Test] // IndexOf (String, Int32, Int32)
1756 public void IndexOf7 ()
1757 {
1758 string s = "testing123456test";
1759
1760 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1761
1762 Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#A1");
1763 Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#A2");
1764 Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#A3");
1765 Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#A4");
1766 Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#A5");
1767 Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#A6");
1768
1769 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#B1");
1770 Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#B2");
1771 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#B3");
1772 Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#B4");
1773 Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#B5");
1774 Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#B6");
1775
1776 Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#C1");
1777 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#C2");
1778 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#C3");
1779 Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#C4");
1780 Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#C5");
1781 Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#C6");
1782
1783 Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#D1");
1784 Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#D2");
1785 Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#D3");
1786 Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#D4");
1787 Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#D5");
1788 Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#D6");
1789
1790 Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#E1");
1791 Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#E2");
1792 Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#E3");
1793 Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#E4");
1794 Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#E5");
1795 Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#E6");
1796 Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#E7");
1797 Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#E8");
1798 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#E9");
1799 Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#E10");
1800
1801 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1802
1803 Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#F1");
1804 Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#F2");
1805 Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#F3");
1806 Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#F4");
1807 Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#F5");
1808 Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#F6");
1809
1810 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#G1");
1811 Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#G2");
1812 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#G3");
1813 Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#G4");
1814 Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#G5");
1815 Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#G6");
1816
1817 Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#H1");
1818 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#H2");
1819 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#H3");
1820 Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#H4");
1821 Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#H5");
1822 Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#H6");
1823
1824 Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#I1");
1825 Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#I2");
1826 Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#I3");
1827 Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#I4");
1828 Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#I5");
1829 Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#I6");
1830
1831 Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#J1");
1832 Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#J2");
1833 Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#J3");
1834 Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#J4");
1835 Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#J5");
1836 Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#J6");
1837 Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#J7");
1838 Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#J8");
1839 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#J9");
1840 Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#J10");
1841 }
1842
1843 [Test]
1844 public void IndexOf7_Empty ()
1845 {
1846 Assert.AreEqual (1, "FOO".IndexOf ("", 1, 2, StringComparison.Ordinal));
1847 Assert.AreEqual (1, "FOO".IndexOf ("", 1, 2, StringComparison.OrdinalIgnoreCase));
1848 }
1849
1850 [Test] // IndexOf (String, Int32, Int32)
1851 public void IndexOf7_Count_Negative ()
1852 {
1853 try {
1854 "Mono".IndexOf ("no", 1, -1);
1855 Assert.Fail ("#1");
1856 } catch (ArgumentOutOfRangeException ex) {
1857 // Count must be positive and count must refer to a
1858 // location within the string/array/collection
1859 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1860 Assert.IsNull (ex.InnerException, "#3");
1861 Assert.IsNotNull (ex.Message, "#4");
1862 Assert.AreEqual ("count", ex.ParamName, "#5");
1863 }
1864 }
1865
1866 [Test] // IndexOf (String, Int32, Int32)
1867 public void IndexOf7_Count_Overflow ()
1868 {
1869 string s = "testing123456";
1870
1871 try {
1872 s.IndexOf ("no", 1, s.Length);
1873 Assert.Fail ("#A1");
1874 } catch (ArgumentOutOfRangeException ex) {
1875 // Count must be positive and count must refer to a
1876 // location within the string/array/collection
1877 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1878 Assert.IsNull (ex.InnerException, "#A3");
1879 Assert.IsNotNull (ex.Message, "#A4");
1880 Assert.AreEqual ("count", ex.ParamName, "#A5");
1881 }
1882
1883 try {
1884 s.IndexOf ("no", 1, s.Length + 1);
1885 Assert.Fail ("#B1");
1886 } catch (ArgumentOutOfRangeException ex) {
1887 // Count must be positive and count must refer to a
1888 // location within the string/array/collection
1889 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1890 Assert.IsNull (ex.InnerException, "#B3");
1891 Assert.IsNotNull (ex.Message, "#B4");
1892 Assert.AreEqual ("count", ex.ParamName, "#B5");
1893 }
1894
1895 try {
1896 s.IndexOf ("no", 1, int.MaxValue);
1897 Assert.Fail ("#C1");
1898 } catch (ArgumentOutOfRangeException ex) {
1899 // Count must be positive and count must refer to a
1900 // location within the string/array/collection
1901 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1902 Assert.IsNull (ex.InnerException, "#C3");
1903 Assert.IsNotNull (ex.Message, "#C4");
1904 Assert.AreEqual ("count", ex.ParamName, "#C5");
1905 }
1906 }
1907
1908 [Test] // IndexOf (String, Int32, Int32)
1909 public void IndexOf7_StartIndex_Negative ()
1910 {
1911 try {
1912 "Mono".IndexOf ("no", -1, 1);
1913 Assert.Fail ("#1");
1914 } catch (ArgumentOutOfRangeException ex) {
1915 // Index was out of range. Must be non-negative and
1916 // less than the size of the collection
1917 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1918 Assert.IsNull (ex.InnerException, "#3");
1919 Assert.IsNotNull (ex.Message, "#4");
1920 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1921 }
1922 }
1923
1924 [Test] // IndexOf (String, Int32, Int32)
1925 public void IndexOf7_StartIndex_Overflow ()
1926 {
1927 string s = "testing123456";
1928
1929 try {
1930 s.IndexOf ("no", s.Length + 1, 1);
1931 Assert.Fail ("#A1");
1932 } catch (ArgumentOutOfRangeException ex) {
1933 // Index was out of range. Must be non-negative and
1934 // less than the size of the collection
1935 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1936 Assert.IsNull (ex.InnerException, "#A3");
1937 Assert.IsNotNull (ex.Message, "#A4");
1938 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
1939 }
1940
1941 try {
1942 s.IndexOf ("no", int.MaxValue, 1);
1943 Assert.Fail ("#B1");
1944 } catch (ArgumentOutOfRangeException ex) {
1945 // Index was out of range. Must be non-negative and
1946 // less than the size of the collection
1947 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1948 Assert.IsNull (ex.InnerException, "#B3");
1949 Assert.IsNotNull (ex.Message, "#B4");
1950 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
1951 }
1952 }
1953
1954 [Test] // IndexOf (String, Int32, Int32)
1955 public void IndexOf7_Value_Null ()
1956 {
1957 try {
1958 "Mono".IndexOf ((string) null, 0, 1);
1959 Assert.Fail ("#1");
1960 } catch (ArgumentNullException ex) {
1961 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1962 Assert.IsNull (ex.InnerException, "#3");
1963 Assert.IsNotNull (ex.Message, "#4");
1964 Assert.AreEqual ("value", ex.ParamName, "#5");
1965 }
1966 }
1967
1968 [Test] // IndexOf (String, Int32, StringComparison)
1969 public void IndexOf8_ComparisonType_Invalid ()
1970 {
1971 try {
1972 "Mono".IndexOf (string.Empty, 1, (StringComparison) Int32.MinValue);
1973 Assert.Fail ("#1");
1974 } catch (ArgumentException ex) {
1975 // The string comparison type passed in is currently
1976 // not supported
1977 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1978 Assert.IsNull (ex.InnerException, "#3");
1979 Assert.IsNotNull (ex.Message, "#4");
1980 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
1981 }
1982 }
1983
1984 [Test] // IndexOf (String, Int32, StringComparison)
1985 public void IndexOf8_StartIndex_Negative ()
1986 {
1987 try {
1988 "Mono".IndexOf ("o", -1, StringComparison.Ordinal);
1989 Assert.Fail ("#1");
1990 } catch (ArgumentOutOfRangeException ex) {
1991 // Index was out of range. Must be non-negative and
1992 // less than the size of the collection
1993 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1994 Assert.IsNull (ex.InnerException, "#3");
1995 Assert.IsNotNull (ex.Message, "#4");
1996 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1997 }
1998 }
1999
2000 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2001 public void IndexOf9_ComparisonType_Invalid ()
2002 {
2003 try {
2004 "Mono".IndexOf (string.Empty, 0, 1, (StringComparison) Int32.MinValue);
2005 Assert.Fail ("#1");
2006 } catch (ArgumentException ex) {
2007 // The string comparison type passed in is currently
2008 // not supported
2009 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2010 Assert.IsNull (ex.InnerException, "#3");
2011 Assert.IsNotNull (ex.Message, "#4");
2012 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
2013 }
2014 }
2015
2016 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2017 public void IndexOf9_Count_Negative ()
2018 {
2019 try {
2020 "Mono".IndexOf ("o", 1, -1, StringComparison.Ordinal);
2021 Assert.Fail ("#1");
2022 Assert.Fail ("#1");
2023 } catch (ArgumentOutOfRangeException ex) {
2024 // Count must be positive and count must refer to a
2025 // location within the string/array/collection
2026 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2027 Assert.IsNull (ex.InnerException, "#3");
2028 Assert.IsNotNull (ex.Message, "#4");
2029 Assert.AreEqual ("count", ex.ParamName, "#5");
2030 }
2031 }
2032
2033 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2034 public void IndexOf9_StartIndex_Negative ()
2035 {
2036 try {
2037 "Mono".IndexOf ("o", -1, 0, StringComparison.Ordinal);
2038 Assert.Fail ("#1");
2039 } catch (ArgumentOutOfRangeException ex) {
2040 // Index was out of range. Must be non-negative and
2041 // less than the size of the collection
2042 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2043 Assert.IsNull (ex.InnerException, "#3");
2044 Assert.IsNotNull (ex.Message, "#4");
2045 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2046 }
2047 }
2048
2049 [Test]
2050 public void IndexOfAny1 ()
2051 {
2052 string s = "abcdefghijklmd";
2053 char[] c;
2054
2055 c = new char [] {'a', 'e', 'i', 'o', 'u'};
2056 Assert.AreEqual (0, s.IndexOfAny (c), "#1");
2057 c = new char [] { 'd', 'z' };
2058 Assert.AreEqual (3, s.IndexOfAny (c), "#1");
2059 c = new char [] { 'q', 'm', 'z' };
2060 Assert.AreEqual (12, s.IndexOfAny (c), "#2");
2061 c = new char [0];
2062 Assert.AreEqual (-1, s.IndexOfAny (c), "#3");
2063
2064 }
2065
2066 [Test] // IndexOfAny (Char [])
2067 public void IndexOfAny1_AnyOf_Null ()
2068 {
2069 try {
2070 "mono".IndexOfAny ((char []) null);
2071 Assert.Fail ("#1");
2072 } catch (ArgumentNullException ex) {
2073 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2074 Assert.IsNull (ex.InnerException, "#3");
2075 Assert.IsNotNull (ex.Message, "#4");
2076 Assert.IsNull (ex.ParamName, "#5");
2077 }
2078 }
2079
2080 [Test] // IndexOfAny (Char [], Int32)
2081 public void IndexOfAny2 ()
2082 {
2083 string s = "abcdefghijklmd";
2084 char [] c;
2085
2086 c = new char [] { 'a', 'e', 'i', 'o', 'u' };
2087 Assert.AreEqual (0, s.IndexOfAny (c, 0), "#A1");
2088 Assert.AreEqual (4, s.IndexOfAny (c, 1), "#A1");
2089 Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#A2");
2090 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#A3");
2091
2092 c = new char [] { 'd', 'z' };
2093 Assert.AreEqual (3, s.IndexOfAny (c, 0), "#B1");
2094 Assert.AreEqual (3, s.IndexOfAny (c, 3), "#B2");
2095 Assert.AreEqual (13, s.IndexOfAny (c, 4), "#B3");
2096 Assert.AreEqual (13, s.IndexOfAny (c, 9), "#B4");
2097 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#B5");
2098 Assert.AreEqual (13, s.IndexOfAny (c, s.Length - 1), "#B6");
2099
2100 c = new char [] { 'q', 'm', 'z' };
2101 Assert.AreEqual (12, s.IndexOfAny (c, 0), "#C1");
2102 Assert.AreEqual (12, s.IndexOfAny (c, 4), "#C2");
2103 Assert.AreEqual (12, s.IndexOfAny (c, 12), "#C3");
2104 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#C4");
2105
2106 c = new char [0];
2107 Assert.AreEqual (-1, s.IndexOfAny (c, 0), "#D1");
2108 Assert.AreEqual (-1, s.IndexOfAny (c, 4), "#D2");
2109 Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#D3");
2110 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#D4");
2111 }
2112
2113 [Test] // IndexOfAny (Char [], Int32)
2114 public void IndexOfAny2_AnyOf_Null ()
2115 {
2116 try {
2117 "mono".IndexOfAny ((char []) null, 0);
2118 Assert.Fail ("#1");
2119 } catch (ArgumentNullException ex) {
2120 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2121 Assert.IsNull (ex.InnerException, "#3");
2122 Assert.IsNotNull (ex.Message, "#4");
2123 Assert.IsNull (ex.ParamName, "#5");
2124 }
2125 }
2126
2127 [Test] // IndexOfAny (Char [], Int32)
2128 public void IndexOfAny2_StartIndex_Negative ()
2129 {
2130 string s = "abcdefghijklm";
2131
2132 try {
2133 s.IndexOfAny (new char [1] { 'd' }, -1, 1);
2134 Assert.Fail ("#1");
2135 } catch (ArgumentOutOfRangeException ex) {
2136 // Specified argument was out of the range of valid
2137 // values
2138 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2139 Assert.IsNull (ex.InnerException, "#3");
2140 Assert.IsNotNull (ex.Message, "#4");
2141 Assert.IsNull (ex.ParamName, "#5");
2142 }
2143 }
2144
2145 [Test] // IndexOfAny (Char [], Int32, Int32)
2146 public void IndexOfAny2_StartIndex_Overflow ()
2147 {
2148 string s = "abcdefghijklm";
2149
2150 try {
2151 s.IndexOfAny (new char [1] { 'd' }, s.Length + 1);
2152 Assert.Fail ("#1");
2153 } catch (ArgumentOutOfRangeException ex) {
2154 // Specified argument was out of the range of valid
2155 // values
2156 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2157 Assert.IsNull (ex.InnerException, "#3");
2158 Assert.IsNotNull (ex.Message, "#4");
2159 Assert.IsNull (ex.ParamName, "#5");
2160 }
2161 }
2162
2163 [Test] // IndexOfAny (Char [], Int32, Int32)
2164 public void IndexOfAny3 ()
2165 {
2166 string s = "abcdefghijklmd";
2167 char [] c;
2168
2169 c = new char [] { 'a', 'e', 'i', 'o', 'u' };
2170 Assert.AreEqual (0, s.IndexOfAny (c, 0, 2), "#A1");
2171 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#A2");
2172 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#A3");
2173 Assert.AreEqual (4, s.IndexOfAny (c, 1, 4), "#A3");
2174 Assert.AreEqual (4, s.IndexOfAny (c, 1, s.Length - 1), "#A4");
2175
2176 c = new char [] { 'd', 'z' };
2177 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 2), "#B1");
2178 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#B2");
2179 Assert.AreEqual (3, s.IndexOfAny (c, 1, 3), "#B3");
2180 Assert.AreEqual (3, s.IndexOfAny (c, 0, s.Length), "#B4");
2181 Assert.AreEqual (3, s.IndexOfAny (c, 1, s.Length - 1), "#B5");
2182 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length, 0), "#B6");
2183
2184 c = new char [] { 'q', 'm', 'z' };
2185 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 10), "#C1");
2186 Assert.AreEqual (12, s.IndexOfAny (c, 10, 4), "#C2");
2187 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#C3");
2188 Assert.AreEqual (12, s.IndexOfAny (c, 0, s.Length), "#C4");
2189 Assert.AreEqual (12, s.IndexOfAny (c, 1, s.Length - 1), "#C5");
2190
2191 c = new char [0];
2192 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 3), "#D1");
2193 Assert.AreEqual (-1, s.IndexOfAny (c, 4, 9), "#D2");
2194 Assert.AreEqual (-1, s.IndexOfAny (c, 9, 5), "#D3");
2195 Assert.AreEqual (-1, s.IndexOfAny (c, 13, 1), "#D4");
2196 }
2197
2198 [Test] // IndexOfAny (Char [], Int32, Int32)
2199 public void IndexOfAny3_AnyOf_Null ()
2200 {
2201 try {
2202 "mono".IndexOfAny ((char []) null, 0, 0);
2203 Assert.Fail ("#1");
2204 } catch (ArgumentNullException ex) {
2205 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2206 Assert.IsNull (ex.InnerException, "#3");
2207 Assert.IsNotNull (ex.Message, "#4");
2208 Assert.IsNull (ex.ParamName, "#5");
2209 }
2210 }
2211
2212 [Test] // IndexOfAny (Char [], Int32, Int32)
2213 public void IndexOfAny3_Count_Negative ()
2214 {
2215 try {
2216 "Mono".IndexOfAny (new char [1] { 'o' }, 1, -1);
2217 Assert.Fail ("#1");
2218 } catch (ArgumentOutOfRangeException ex) {
2219 // Count must be positive and count must refer to a
2220 // location within the string/array/collection
2221 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2222 Assert.IsNull (ex.InnerException, "#3");
2223 Assert.IsNotNull (ex.Message, "#4");
2224 Assert.AreEqual ("count", ex.ParamName, "#5");
2225 }
2226 }
2227
2228 [Test] // IndexOfAny (Char [], Int32, Int32)
2229 public void IndexOfAny3_Length_Overflow ()
2230 {
2231 string s = "abcdefghijklm";
2232
2233 try {
2234 s.IndexOfAny (new char [1] { 'd' }, 1, s.Length);
2235 Assert.Fail ("#1");
2236 } catch (ArgumentOutOfRangeException ex) {
2237 // Count must be positive and count must refer to a
2238 // location within the string/array/collection
2239 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2240 Assert.IsNull (ex.InnerException, "#3");
2241 Assert.IsNotNull (ex.Message, "#4");
2242 Assert.AreEqual ("count", ex.ParamName, "#5");
2243 }
2244 }
2245
2246 [Test] // IndexOfAny (Char [], Int32, Int32)
2247 public void IndexOfAny3_StartIndex_Negative ()
2248 {
2249 try {
2250 "Mono".IndexOfAny (new char [1] { 'o' }, -1, 1);
2251 Assert.Fail ("#1");
2252 } catch (ArgumentOutOfRangeException ex) {
2253 // Specified argument was out of the range of valid
2254 // values
2255 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2256 Assert.IsNull (ex.InnerException, "#3");
2257 Assert.IsNotNull (ex.Message, "#4");
2258 Assert.IsNull (ex.ParamName, "#5");
2259 }
2260 }
2261
2262 [Test] // IndexOfAny (Char [], Int32, Int32)
2263 public void IndexOfAny3_StartIndex_Overflow ()
2264 {
2265 string s = "abcdefghijklm";
2266
2267 try {
2268 s.IndexOfAny (new char [1] { 'o' }, s.Length + 1, 1);
2269 Assert.Fail ("#1");
2270 } catch (ArgumentOutOfRangeException ex) {
2271 // Specified argument was out of the range of valid
2272 // values
2273 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2274 Assert.IsNull (ex.InnerException, "#3");
2275 Assert.IsNotNull (ex.Message, "#4");
2276 Assert.IsNull (ex.ParamName, "#5");
2277 }
2278 }
2279
2280 [Test]
2281 public void Contains ()
2282 {
2283 Assert.IsTrue ("ABC".Contains (string.Empty));
2284 Assert.IsTrue ("ABC".Contains ("ABC"));
2285 Assert.IsTrue ("ABC".Contains ("AB"));
2286 Assert.IsTrue (!"ABC".Contains ("AD"));
2287 Assert.IsTrue (!"encyclopædia".Contains("encyclopaedia"));
2288 }
2289
2290 [Test]
2291 public void IndexOfIsCultureAwareWhileContainsIsNot ()
2292 {
2293 string a = "encyclopædia";
2294 string b = "encyclopaedia";
2295 Assert.IsFalse (a.Contains (b), "#1");
2296 Assert.IsTrue (a.Contains ("æ"), "#1.1");
2297 Assert.IsFalse (b.Contains ("æ"), "#1.2");
2298 Assert.AreEqual (0, a.IndexOf (b), "#2");
2299 Assert.AreEqual (8, a.IndexOf ('æ'), "#3");
2300 Assert.AreEqual (-1, b.IndexOf ('æ'), "#4");
2301 Assert.AreEqual (8, a.IndexOf ("æ"), "#5");
2302 Assert.AreEqual (8, b.IndexOf ("æ"), "#6");
2303
2304 Assert.AreEqual (0, CultureInfo.CurrentCulture.CompareInfo.IndexOf (a, b, 0, a.Length, CompareOptions.None), "#7");
2305 Assert.AreEqual (-1, CultureInfo.CurrentCulture.CompareInfo.IndexOf (a, b, 0, a.Length, CompareOptions.Ordinal), "#8");
2306 }
2307
2308 [Test]
2309 public void Contains_Value_Null ()
2310 {
2311 try {
2312 "ABC".Contains (null);
2313 Assert.Fail ("#1");
2314 } catch (ArgumentNullException ex) {
2315 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2316 Assert.IsNull (ex.InnerException, "#3");
2317 Assert.IsNotNull (ex.Message, "#4");
2318 Assert.AreEqual ("value", ex.ParamName, "#5");
2319 }
2320 }
2321
2322 [Test]
2323 public void IsNullOrEmpty ()
2324 {
2325 Assert.IsTrue (String.IsNullOrEmpty (null));
2326 Assert.IsTrue (String.IsNullOrEmpty (String.Empty));
2327 Assert.IsTrue (String.IsNullOrEmpty (""));
2328 Assert.IsTrue (!String.IsNullOrEmpty ("A"));
2329 Assert.IsTrue (!String.IsNullOrEmpty (" "));
2330 Assert.IsTrue (!String.IsNullOrEmpty ("\t"));
2331 Assert.IsTrue (!String.IsNullOrEmpty ("\n"));
2332 }
2333
2334 [Test]
2335 public void TestInsert ()
2336 {
2337 string s1 = "original";
2338
2339 try {
2340 s1.Insert (0, null);
2341 Assert.Fail ("#A1");
2342 } catch (ArgumentNullException ex) {
2343 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2344 Assert.IsNull (ex.InnerException, "#A3");
2345 Assert.IsNotNull (ex.Message, "#A4");
2346 Assert.AreEqual ("value", ex.ParamName, "#A5");
2347 }
2348
2349 try {
2350 s1.Insert (s1.Length + 1, "Hi!");
2351 Assert.Fail ("#B1");
2352 } catch (ArgumentOutOfRangeException ex) {
2353 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
2354 Assert.IsNull (ex.InnerException, "#B3");
2355 Assert.IsNotNull (ex.Message, "#B4");
2356 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
2357 }
2358
2359 Assert.AreEqual ("Hi!original", s1.Insert (0, "Hi!"), "#C1");
2360 Assert.AreEqual ("originalHi!", s1.Insert (s1.Length, "Hi!"), "#C2");
2361 Assert.AreEqual ("origHi!inal", s1.Insert (4, "Hi!"), "#C3");
2362 }
2363
2364 [Test]
2365 public void Intern ()
2366 {
2367 string s1 = "original";
2368 Assert.AreSame (s1, String.Intern (s1), "#A1");
2369 Assert.AreSame (String.Intern(s1), String.Intern(s1), "#A2");
2370
2371 string s2 = "originally";
2372 Assert.AreSame (s2, String.Intern (s2), "#B1");
2373 Assert.IsTrue (String.Intern(s1) != String.Intern(s2), "#B2");
2374
2375 string s3 = new DateTime (2000, 3, 7).ToString ();
2376 Assert.IsNull (String.IsInterned (s3), "#C1");
2377
2378 string s4 = String.Intern (s3);
2379 Assert.AreEqual (s3, s4, "#C2");
2380 Assert.AreSame (s4, String.IsInterned (s4), "#C3");
2381 Assert.AreSame (s4, String.IsInterned (new DateTime (2000, 3, 7).ToString ()), "#C4");
2382 Assert.AreSame (s4, String.Intern (new DateTime (2000, 3, 7).ToString ()), "#C5");
2383 }
2384
2385 [Test]
2386 public void Intern_Str_Null ()
2387 {
2388 try {
2389 String.Intern (null);
2390 Assert.Fail ("#1");
2391 } catch (ArgumentNullException ex) {
2392 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2393 Assert.IsNull (ex.InnerException, "#3");
2394 Assert.IsNotNull (ex.Message, "#4");
2395 Assert.AreEqual ("str", ex.ParamName, "#5");
2396 }
2397 }
2398
2399 [Test]
2400 public void IsInterned ()
2401 {
2402 Assert.IsNull (String.IsInterned (new DateTime (2000, 3, 6).ToString ()), "#1");
2403 string s1 = "original";
2404 Assert.AreSame (s1, String.IsInterned (s1), "#2");
2405 }
2406
2407 [Test]
2408 public void IsInterned_Str_Null ()
2409 {
2410 try {
2411 String.IsInterned (null);
2412 Assert.Fail ("#1");
2413 } catch (ArgumentNullException ex) {
2414 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2415 Assert.IsNull (ex.InnerException, "#3");
2416 Assert.IsNotNull (ex.Message, "#4");
2417 Assert.AreEqual ("str", ex.ParamName, "#5");
2418 }
2419 }
2420
2421 [Test]
2422 public void TestJoin ()
2423 {
2424 try {
2425 string s = String.Join(" ", null);
2426 Assert.Fail ("#A1");
2427 } catch (ArgumentNullException ex) {
2428 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2429 Assert.IsNull (ex.InnerException, "#A3");
2430 Assert.IsNotNull (ex.Message, "#A4");
2431 Assert.AreEqual ("value", ex.ParamName, "#A5");
2432 }
2433
2434 string[] chunks = {"this", "is", "a", "test"};
2435 Assert.AreEqual ("this is a test", String.Join(" ", chunks), "Basic join");
2436 Assert.AreEqual ("this.is.a.test", String.Join(".", chunks), "Basic join");
2437
2438 Assert.AreEqual ("is a", String.Join(" ", chunks, 1, 2), "Subset join");
2439 Assert.AreEqual ("is.a", String.Join(".", chunks, 1, 2), "Subset join");
2440 Assert.AreEqual ("is a test", String.Join(" ", chunks, 1, 3), "Subset join");
2441
2442 try {
2443 string s = String.Join(" ", chunks, 2, 3);
2444 Assert.Fail ("#C1");
2445 } catch (ArgumentOutOfRangeException ex) {
2446 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
2447 Assert.IsNull (ex.InnerException, "#C3");
2448 Assert.IsNotNull (ex.Message, "#C4");
2449 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
2450 }
2451 }
2452
2453 [Test]
2454 public void Join_SeparatorNull ()
2455 {
2456 string[] chunks = {"this", "is", "a", "test"};
2457 Assert.AreEqual ("thisisatest", String.Join (null, chunks), "SeparatorNull");
2458 }
2459
2460 [Test]
2461 public void Join_ValuesNull ()
2462 {
2463 string[] chunks1 = {null, "is", "a", null};
2464 Assert.AreEqual (" is a ", String.Join (" ", chunks1), "SomeNull");
2465
2466 string[] chunks2 = {null, "is", "a", null};
2467 Assert.AreEqual ("isa", String.Join (null, chunks2), "Some+Sep=Null");
2468
2469 string[] chunks3 = {null, null, null, null};
2470 Assert.AreEqual (" ", String.Join (" ", chunks3), "AllValuesNull");
2471 }
2472
2473 [Test]
2474 public void Join_AllNull ()
2475 {
2476 string[] chunks = {null, null, null};
2477 Assert.AreEqual (string.Empty, String.Join (null, chunks), "AllNull");
2478 }
2479
2480 [Test]
2481 public void Join_StartIndexNegative ()
2482 {
2483 string[] values = { "Mo", "no" };
2484 try {
2485 String.Join ("o", values, -1, 1);
2486 Assert.Fail ("#1");
2487 } catch (ArgumentOutOfRangeException ex) {
2488 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2489 Assert.IsNull (ex.InnerException, "#3");
2490 Assert.IsNotNull (ex.Message, "#4");
2491 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2492 }
2493 }
2494
2495 [Test]
2496 public void Join_StartIndexOverflow ()
2497 {
2498 string[] values = { "Mo", "no" };
2499 try {
2500 String.Join ("o", values, Int32.MaxValue, 1);
2501 Assert.Fail ("#1");
2502 } catch (ArgumentOutOfRangeException ex) {
2503 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2504 Assert.IsNull (ex.InnerException, "#3");
2505 Assert.IsNotNull (ex.Message, "#4");
2506 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2507 }
2508 }
2509
2510 [Test]
2511 public void Join_LengthNegative ()
2512 {
2513 string[] values = { "Mo", "no" };
2514 try {
2515 String.Join ("o", values, 1, -1);
2516 Assert.Fail ("#1");
2517 } catch (ArgumentOutOfRangeException ex) {
2518 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2519 Assert.IsNull (ex.InnerException, "#3");
2520 Assert.IsNotNull (ex.Message, "#4");
2521 Assert.AreEqual ("count", ex.ParamName, "#5");
2522 }
2523 }
2524
2525 [Test]
2526 public void Join_LengthOverflow ()
2527 {
2528 string[] values = { "Mo", "no" };
2529 try {
2530 String.Join ("o", values, 1, Int32.MaxValue);
2531 Assert.Fail ("#1");
2532 } catch (ArgumentOutOfRangeException ex) {
2533 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2534 Assert.IsNull (ex.InnerException, "#3");
2535 Assert.IsNotNull (ex.Message, "#4");
2536 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2537 }
2538 }
2539
2540 [Test]
2541 public void LastIndexOf ()
2542 {
2543 string s1 = "original";
2544
2545 try {
2546 s1.LastIndexOf ('q', -1);
2547 Assert.Fail ("#A1");
2548 } catch (ArgumentOutOfRangeException ex) {
2549 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
2550 Assert.IsNull (ex.InnerException, "#A3");
2551 Assert.IsNotNull (ex.Message, "#A4");
2552 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
2553 }
2554
2555 try {
2556 s1.LastIndexOf ('q', -1, 1);
2557 Assert.Fail ("#B1");
2558 } catch (ArgumentOutOfRangeException ex) {
2559 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
2560 Assert.IsNull (ex.InnerException, "#B3");
2561 Assert.IsNotNull (ex.Message, "#B4");
2562 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
2563 }
2564
2565 try {
2566 s1.LastIndexOf ("huh", s1.Length + 1);
2567 Assert.Fail ("#C1");
2568 } catch (ArgumentOutOfRangeException ex) {
2569 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
2570 Assert.IsNull (ex.InnerException, "#C3");
2571 Assert.IsNotNull (ex.Message, "#C4");
2572 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
2573 }
2574
2575 try {
2576 int i = s1.LastIndexOf ("huh", s1.Length + 1, 3);
2577 Assert.Fail ("#D1");
2578 } catch (ArgumentOutOfRangeException ex) {
2579 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
2580 Assert.IsNull (ex.InnerException, "#D3");
2581 Assert.IsNotNull (ex.Message, "#D4");
2582 Assert.AreEqual ("startIndex", ex.ParamName, "#D5");
2583 }
2584
2585 try {
2586 s1.LastIndexOf (null);
2587 Assert.Fail ("#E1");
2588 } catch (ArgumentNullException ex) {
2589 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#E2");
2590 Assert.IsNull (ex.InnerException, "#E3");
2591 Assert.IsNotNull (ex.Message, "#E4");
2592 Assert.AreEqual ("value", ex.ParamName, "#E5");
2593 }
2594
2595 try {
2596 s1.LastIndexOf (null, 0);
2597 Assert.Fail ("#F1");
2598 } catch (ArgumentNullException ex) {
2599 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#F2");
2600 Assert.IsNull (ex.InnerException, "#F3");
2601 Assert.IsNotNull (ex.Message, "#F4");
2602 Assert.AreEqual ("value", ex.ParamName, "#F5");
2603 }
2604
2605 try {
2606 s1.LastIndexOf (null, 0, 1);
2607 Assert.Fail ("#G1");
2608 } catch (ArgumentNullException ex) {
2609 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#G2");
2610 Assert.IsNull (ex.InnerException, "#G3");
2611 Assert.IsNotNull (ex.Message, "#G4");
2612 Assert.AreEqual ("value", ex.ParamName, "#G5");
2613 }
2614
2615 Assert.AreEqual (1, s1.LastIndexOf('r'), "basic char index");
2616 Assert.AreEqual (4, s1.LastIndexOf('i'), "basic char index");
2617 Assert.AreEqual (-1, s1.LastIndexOf('q'), "basic char index - no");
2618
2619 Assert.AreEqual (7, s1.LastIndexOf(string.Empty), "basic string index");
2620 Assert.AreEqual (1, s1.LastIndexOf("rig"), "basic string index");
2621 Assert.AreEqual (4, s1.LastIndexOf("i"), "basic string index");
2622 Assert.AreEqual (-1, s1.LastIndexOf("rag"), "basic string index - no");
2623
2624 Assert.AreEqual (1, s1.LastIndexOf('r', s1.Length-1), "stepped char index");
2625 Assert.AreEqual (4, s1.LastIndexOf('i', s1.Length-1), "stepped char index");
2626 Assert.AreEqual (2, s1.LastIndexOf('i', 3), "stepped char index");
2627 Assert.AreEqual (-1, s1.LastIndexOf('i', 1), "stepped char index");
2628
2629 Assert.AreEqual (1, s1.LastIndexOf('r', 1, 1), "stepped limited char index");
2630 Assert.AreEqual (-1, s1.LastIndexOf('r', 0, 1), "stepped limited char index");
2631 Assert.AreEqual (4, s1.LastIndexOf('i', 6, 3), "stepped limited char index");
2632 Assert.AreEqual (2, s1.LastIndexOf('i', 3, 3), "stepped limited char index");
2633 Assert.AreEqual (-1, s1.LastIndexOf('i', 1, 2), "stepped limited char index");
2634
2635 s1 = "original original";
2636 Assert.AreEqual (9, s1.LastIndexOf("original", s1.Length), "stepped string index #1");
2637 Assert.AreEqual (0, s1.LastIndexOf("original", s1.Length-2), "stepped string index #2");
2638 Assert.AreEqual (-1, s1.LastIndexOf("original", s1.Length-11), "stepped string index #3");
2639 Assert.AreEqual (-1, s1.LastIndexOf("translator", 2), "stepped string index #4");
2640 Assert.AreEqual (0, string.Empty.LastIndexOf(string.Empty, 0), "stepped string index #5");
2641 Assert.AreEqual (-1, string.Empty.LastIndexOf("A", -1), "stepped string index #6");
2642 Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-1, 10), "stepped limited string index #1");
2643 Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length, 3), "stepped limited string index #2");
2644 Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-2, 15), "stepped limited string index #3");
2645 Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length-2, 3), "stepped limited string index #4");
2646
2647 string s2 = "QBitArray::bitarr_data";
2648 Assert.AreEqual (9, s2.LastIndexOf ("::"), "bug #62160");
2649
2650 string s3 = "test123";
2651 Assert.AreEqual (0, s3.LastIndexOf ("test123"), "bug #77412");
2652
2653 Assert.AreEqual (0, "\u267B RT \u30FC".LastIndexOf ("\u267B RT "), "bug #605094");
2654 }
2655
2656 [Test]
2657 [ExpectedException (typeof (ArgumentException))]
2658 public void LastIndexOf_StringComparison ()
2659 {
2660 " ".LastIndexOf (string.Empty, 0, 1, (StringComparison)Int32.MinValue);
2661 }
2662
2663 [Test]
2664 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2665 public void LastIndexOfStringComparisonOrdinalRangeException1 ()
2666 {
2667 "Mono".LastIndexOf ("no", 5, StringComparison.Ordinal);
2668 }
2669
2670 [Test]
2671 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2672 public void LastIndexOfStringComparisonOrdinalRangeException2 ()
2673 {
2674 "Mono".LastIndexOf ("no", 1, 3, StringComparison.Ordinal);
2675 }
2676
2677 [Test]
2678 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2679 public void LastIndexOfStringComparisonOrdinalIgnoreCaseRangeException1 ()
2680 {
2681 "Mono".LastIndexOf ("no", 5, StringComparison.OrdinalIgnoreCase);
2682 }
2683
2684 [Test]
2685 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2686 public void LastIndexOfStringComparisonOrdinalIgnoreCaseRangeException2 ()
2687 {
2688 "Mono".LastIndexOf ("no", 1, 3, StringComparison.OrdinalIgnoreCase);
2689 }
2690
2691 [Test]
2692 public void LastIndexOfStringComparison ()
2693 {
2694 string text = "testing123456";
2695 string text2 = "123";
2696 string text3 = "NG";
2697 string text4 = "t";
2698 Assert.AreEqual (7, text.LastIndexOf (text2, StringComparison.Ordinal), "#1-1");
2699 Assert.AreEqual (5, text.LastIndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1");
2700
2701 Assert.AreEqual (7, text.LastIndexOf (text2, 12, StringComparison.Ordinal), "#1-2");
2702 Assert.AreEqual (5, text.LastIndexOf (text3, 12, StringComparison.OrdinalIgnoreCase), "#2-2");
2703
2704 Assert.AreEqual (-1, text.LastIndexOf (text2, 0, StringComparison.Ordinal), "#1-3");
2705 Assert.AreEqual (-1, text.LastIndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-3");
2706
2707 Assert.AreEqual (-1, text.LastIndexOf (text2, 6, StringComparison.Ordinal), "#1-4");
2708 Assert.AreEqual (5, text.LastIndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4");
2709
2710 Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5");
2711 Assert.AreEqual (5, text.LastIndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5");
2712
2713 Assert.AreEqual (-1, text.LastIndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6");
2714 Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6");
2715
2716 Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7");
2717 Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7");
2718
2719 Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.Ordinal), "#3-1");
2720 Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2");
2721
2722 Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.Ordinal), "#4-1");
2723 Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2");
2724
2725 Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.Ordinal), "#4-1");
2726 Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.OrdinalIgnoreCase), "#4-2");
2727
2728 Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.Ordinal), "#5-1");
2729 Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.OrdinalIgnoreCase), "#5-2");
2730
2731 Assert.AreEqual (-1, "".LastIndexOf ("FOO", StringComparison.Ordinal));
2732 Assert.AreEqual (0, "".LastIndexOf ("", StringComparison.Ordinal));
2733 }
2734
2735 [Test]
2736 public void LastIndexOfStringComparisonOrdinal ()
2737 {
2738 string text = "testing123456";
2739 Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.Ordinal), "#1");
2740 Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.Ordinal), "#2");
2741 Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.Ordinal), "#3");
2742 Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.Ordinal), "#4");
2743 Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.Ordinal), "#5");
2744 Assert.AreEqual (-1, text.LastIndexOf ("S", StringComparison.Ordinal), "#6");
2745 }
2746
2747 [Test]
2748 public void LastIndexOfStringComparisonOrdinalIgnoreCase ()
2749 {
2750 string text = "testing123456";
2751 Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1");
2752 Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2");
2753 Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3");
2754 Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4");
2755 Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5");
2756 Assert.AreEqual (2, text.LastIndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6");
2757 }
2758
2759 [Test]
2760 public void LastIndexOf_Char_StartIndexStringLength ()
2761 {
2762 string s = "Mono";
2763 try {
2764 s.LastIndexOf ('n', s.Length, 1);
2765 Assert.Fail ("#1");
2766 } catch (ArgumentOutOfRangeException ex) {
2767 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2768 Assert.IsNull (ex.InnerException, "#3");
2769 Assert.IsNotNull (ex.Message, "#4");
2770 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2771 }
2772 // this works for string but not for a char
2773 }
2774
2775 [Test]
2776 public void LastIndexOf_Char_StartIndexOverflow ()
2777 {
2778 try {
2779 "Mono".LastIndexOf ('o', Int32.MaxValue, 1);
2780 Assert.Fail ("#1");
2781 } catch (ArgumentOutOfRangeException ex) {
2782 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2783 Assert.IsNull (ex.InnerException, "#3");
2784 Assert.IsNotNull (ex.Message, "#4");
2785 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2786 }
2787 }
2788
2789 [Test]
2790 public void LastIndexOf_Char_LengthOverflow ()
2791 {
2792 try {
2793 "Mono".LastIndexOf ('o', 1, Int32.MaxValue);
2794 Assert.Fail ("#1");
2795 } catch (ArgumentOutOfRangeException ex) {
2796 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2797 Assert.IsNull (ex.InnerException, "#3");
2798 Assert.IsNotNull (ex.Message, "#4");
2799 Assert.AreEqual ("count", ex.ParamName, "#5");
2800 }
2801 }
2802
2803 [Test]
2804 public void LastIndexOf_String_StartIndexStringLength ()
2805 {
2806 string s = "Mono";
2807 Assert.AreEqual (-1, s.LastIndexOf ("n", s.Length, 1));
2808 // this works for string but not for a char
2809 }
2810
2811 [Test]
2812 public void LastIndexOf_String_StartIndexStringLength_Plus1 ()
2813 {
2814 string s = "Mono";
2815 try {
2816 s.LastIndexOf ("n", s.Length + 1, 1);
2817 Assert.Fail ("#1");
2818 } catch (ArgumentOutOfRangeException ex) {
2819 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2820 Assert.IsNull (ex.InnerException, "#3");
2821 Assert.IsNotNull (ex.Message, "#4");
2822 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2823 }
2824 }
2825
2826 [Test]
2827 public void LastIndexOf_String_StartIndexOverflow ()
2828 {
2829 try {
2830 "Mono".LastIndexOf ("no", Int32.MaxValue, 1);
2831 Assert.Fail ("#1");
2832 } catch (ArgumentOutOfRangeException ex) {
2833 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2834 Assert.IsNull (ex.InnerException, "#3");
2835 Assert.IsNotNull (ex.Message, "#4");
2836 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2837 }
2838 }
2839
2840 [Test]
2841 public void LastIndexOf_String_LengthOverflow ()
2842 {
2843 try {
2844 "Mono".LastIndexOf ("no", 1, Int32.MaxValue);
2845 Assert.Fail ("#1");
2846 } catch (ArgumentOutOfRangeException ex) {
2847 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2848 Assert.IsNull (ex.InnerException, "#3");
2849 Assert.IsNotNull (ex.Message, "#4");
2850 Assert.AreEqual ("count", ex.ParamName, "#5");
2851 }
2852 }
2853
2854 [Test]
2855 public void LastIndexOfAny ()
2856 {
2857 string s1 = ".bcdefghijklm";
2858
2859 try {
2860 s1.LastIndexOfAny (null);
2861 Assert.Fail ("#A1");
2862 } catch (ArgumentNullException ex) {
2863 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2864 Assert.IsNull (ex.InnerException, "#A3");
2865 Assert.IsNotNull (ex.Message, "#A4");
2866 Assert.IsNull (ex.ParamName, "#A5");
2867 }
2868
2869 try {
2870 s1.LastIndexOfAny (null, s1.Length);
2871 Assert.Fail ("#B1");
2872 } catch (ArgumentNullException ex) {
2873 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
2874 Assert.IsNull (ex.InnerException, "#B3");
2875 Assert.IsNotNull (ex.Message, "#B4");
2876 Assert.IsNull (ex.ParamName, "#B5");
2877 }
2878
2879 try {
2880 s1.LastIndexOfAny (null, s1.Length, 1);
2881 Assert.Fail ("#C1");
2882 } catch (ArgumentNullException ex) {
2883 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
2884 Assert.IsNull (ex.InnerException, "#C3");
2885 Assert.IsNotNull (ex.Message, "#C4");
2886 Assert.IsNull (ex.ParamName, "#C5");
2887 }
2888
2889 char[] c1 = {'a', 'e', 'i', 'o', 'u'};
2890 Assert.AreEqual (8, s1.LastIndexOfAny (c1), "#D1");
2891 Assert.AreEqual (4, s1.LastIndexOfAny (c1, 7), "#D2");
2892 Assert.AreEqual (-1, s1.LastIndexOfAny (c1, 3), "#D3");
2893 Assert.AreEqual (4, s1.LastIndexOfAny (c1, s1.Length - 6, 4), "#D4");
2894 Assert.AreEqual (-1, s1.LastIndexOfAny (c1, s1.Length - 6, 3), "#D5");
2895
2896 try {
2897 s1.LastIndexOfAny (c1, -1);
2898 Assert.Fail ("#E1");
2899 } catch (ArgumentOutOfRangeException ex) {
2900 // Index was out of range. Must be non-negative and
2901 // less than the size of the collection
2902 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2");
2903 Assert.IsNull (ex.InnerException, "#E3");
2904 Assert.IsNotNull (ex.Message, "#E4");
2905 Assert.AreEqual ("startIndex", ex.ParamName, "#E5");
2906 }
2907
2908 try {
2909 s1.LastIndexOfAny (c1, -1, 1);
2910 Assert.Fail ("#F1");
2911 } catch (ArgumentOutOfRangeException ex) {
2912 // Index was out of range. Must be non-negative and
2913 // less than the size of the collection
2914 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#F2");
2915 Assert.IsNull (ex.InnerException, "#F3");
2916 Assert.IsNotNull (ex.Message, "#F4");
2917 Assert.AreEqual ("startIndex", ex.ParamName, "#F5");
2918 }
2919 }
2920
2921 [Test]
2922 public void LastIndexOfAny_Length_Overflow ()
2923 {
2924 try {
2925 "Mono".LastIndexOfAny (new char [1] { 'o' }, 1, Int32.MaxValue);
2926 Assert.Fail ("#1");
2927 } catch (ArgumentOutOfRangeException ex) {
2928 // Count must be positive and count must refer to a
2929 // location within the string/array/collection
2930 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2931 Assert.IsNull (ex.InnerException, "#3");
2932 Assert.IsNotNull (ex.Message, "#4");
2933 Assert.AreEqual ("count", ex.ParamName, "#5");
2934 }
2935 }
2936
2937 [Test]
2938 public void LastIndexOfAny_StartIndex_Overflow ()
2939 {
2940 try {
2941 "Mono".LastIndexOfAny (new char [1] { 'o' }, Int32.MaxValue, 1);
2942 Assert.Fail ("#1");
2943 } catch (ArgumentOutOfRangeException ex) {
2944 // Index was out of range. Must be non-negative and
2945 // less than the size of the collection
2946 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2947 Assert.IsNull (ex.InnerException, "#3");
2948 Assert.IsNotNull (ex.Message, "#4");
2949 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2950 }
2951 }
2952
2953 [Test] // PadLeft (Int32)
2954 public void PadLeft1 ()
2955 {
2956 string s1 = "Hi!";
2957 string result;
2958
2959 result = s1.PadLeft (0);
2960 Assert.AreSame (s1, result, "#A");
2961
2962 result = s1.PadLeft (s1.Length - 1);
2963 Assert.AreSame (s1, result, "#B");
2964
2965 result = s1.PadLeft (s1.Length);
2966 Assert.AreEqual (s1, result, "#C1");
2967 Assert.IsTrue (!object.ReferenceEquals (s1, result), "#C2");
2968
2969 result = s1.PadLeft (s1.Length + 1);
2970 Assert.AreEqual (" Hi!", result, "#D");
2971 }
2972
2973 [Test] // PadLeft (Int32)
2974 public void PadLeft1_TotalWidth_Negative ()
2975 {
2976 try {
2977 "Mono".PadLeft (-1);
2978 Assert.Fail ("#1");
2979 } catch (ArgumentOutOfRangeException ex) {
2980 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2981 Assert.IsNull (ex.InnerException, "#3");
2982 Assert.IsNotNull (ex.Message, "#4");
2983 Assert.AreEqual ("totalWidth", ex.ParamName, "#5");
2984 }
2985 }
2986
2987 [Test]
2988 public void PadLeft_Overflow ()
2989 {
2990 try {
2991 "x".PadLeft (int.MaxValue, '-');
2992 } catch (OutOfMemoryException) {
2993 }
2994 }
2995
2996 [Test] // PadRight (Int32)
2997 public void PadRight1 ()
2998 {
2999 string s1 = "Hi!";
3000 string result;
3001
3002 result = s1.PadRight (0);
3003 Assert.AreSame (s1, result, "#A");
3004
3005 result = s1.PadRight (s1.Length - 1);
3006 Assert.AreSame (s1, result, "#B");
3007
3008 result = s1.PadRight (s1.Length);
3009 Assert.AreEqual (s1, result, "#C1");
3010 Assert.IsTrue (!object.ReferenceEquals (s1, result), "#C2");
3011
3012 result = s1.PadRight (s1.Length + 1);
3013 Assert.AreEqual ("Hi! ", result, "#D");
3014 }
3015
3016 [Test] // PadRight1 (Int32)
3017 public void PadRight1_TotalWidth_Negative ()
3018 {
3019 try {
3020 "Mono".PadRight (-1);
3021 Assert.Fail ("#1");
3022 } catch (ArgumentOutOfRangeException ex) {
3023 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3024 Assert.IsNull (ex.InnerException, "#3");
3025 Assert.IsNotNull (ex.Message, "#4");
3026 Assert.AreEqual ("totalWidth", ex.ParamName, "#5");
3027 }
3028 }
3029
3030 [Test]
3031 public void PadRight2 ()
3032 {
3033 Assert.AreEqual ("100000000000", "1".PadRight (12, '0'), "#1");
3034 Assert.AreEqual ("000000000000", "".PadRight (12, '0'), "#2");
3035 }
3036
3037 [Test]
3038 public void PadRight_Overflow ()
3039 {
3040 try {
3041 "x".PadRight (int.MaxValue, '-');
3042 } catch (OutOfMemoryException) {
3043 }
3044 }
3045
3046 [Test] // Remove (Int32, Int32)
3047 public void Remove2 ()
3048 {
3049 string s1 = "original";
3050
3051 try {
3052 s1.Remove (-1, 1);
3053 Assert.Fail ("#A1");
3054 } catch (ArgumentOutOfRangeException ex) {
3055 // StartIndex cannot be less than zero
3056 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3057 Assert.IsNull (ex.InnerException, "#A3");
3058 Assert.IsNotNull (ex.Message, "#A4");
3059 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3060 }
3061
3062 try {
3063 s1.Remove (1,-1);
3064 Assert.Fail ("#B1");
3065 } catch (ArgumentOutOfRangeException ex) {
3066 // Count cannot be less than zero
3067 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3068 Assert.IsNull (ex.InnerException, "#B3");
3069 Assert.IsNotNull (ex.Message, "#B4");
3070 Assert.AreEqual ("count", ex.ParamName, "#B5");
3071 }
3072
3073 try {
3074 s1.Remove (s1.Length, s1.Length);
3075 Assert.Fail ("#C1");
3076 } catch (ArgumentOutOfRangeException ex) {
3077 // Index and count must refer to a location within the
3078 // string
3079 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
3080 Assert.IsNull (ex.InnerException, "#C3");
3081 Assert.IsNotNull (ex.Message, "#C4");
3082 Assert.AreEqual ("count", ex.ParamName, "#C5");
3083 }
3084
3085 Assert.AreEqual ("oinal", s1.Remove(1, 3), "#D1");
3086 Assert.AreEqual (s1, s1.Remove (0, 0), "#D2");
3087 Assert.IsTrue (!object.ReferenceEquals (s1, s1.Remove (0, 0)), "#D3");
3088 Assert.AreEqual ("riginal", s1.Remove (0, 1), "#D4");
3089 Assert.AreEqual ("origina", s1.Remove (7, 1), "#D5");
3090 }
3091
3092 [Test] // Remove (Int32, Int32)
3093 public void Remove2_Length_Overflow ()
3094 {
3095 try {
3096 "Mono".Remove (1, Int32.MaxValue);
3097 Assert.Fail ("#1");
3098 } catch (ArgumentOutOfRangeException ex) {
3099 // Index and count must refer to a location within the
3100 // string
3101 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3102 Assert.IsNull (ex.InnerException, "#3");
3103 Assert.IsNotNull (ex.Message, "#4");
3104 Assert.AreEqual ("count", ex.ParamName, "#5");
3105 }
3106 }
3107
3108 [Test] // Remove (Int32, Int32)
3109 public void Remove2_StartIndex_Overflow ()
3110 {
3111 try {
3112 "Mono".Remove (Int32.MaxValue, 1);
3113 Assert.Fail ("#1");
3114 } catch (ArgumentOutOfRangeException ex) {
3115 // Index and count must refer to a location within the
3116 // string
3117 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3118 Assert.IsNull (ex.InnerException, "#3");
3119 Assert.IsNotNull (ex.Message, "#4");
3120 Assert.AreEqual ("count", ex.ParamName, "#5");
3121 }
3122 }
3123
3124 [Test] // Remove (Int32)
3125 public void Remove1_StartIndex_Negative ()
3126 {
3127 try {
3128 "ABC".Remove (-1);
3129 Assert.Fail ("#1");
3130 } catch (ArgumentOutOfRangeException ex) {
3131 // StartIndex cannot be less than zero
3132 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3133 Assert.IsNull (ex.InnerException, "#3");
3134 Assert.IsNotNull (ex.Message, "#4");
3135 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3136 }
3137 }
3138
3139 [Test] // Remove (Int32)
3140 public void Remove1_StartIndex_Overflow ()
3141 {
3142 try {
3143 "ABC".Remove (3);
3144 Assert.Fail ("#1");
3145 } catch (ArgumentOutOfRangeException ex) {
3146 // startIndex must be less than length of string
3147 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3148 Assert.IsNull (ex.InnerException, "#3");
3149 Assert.IsNotNull (ex.Message, "#4");
3150 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3151 }
3152 }
3153
3154 [Test] // Remove (Int32)
3155 public void Remove1 ()
3156 {
3157 string s = "ABC";
3158
3159 Assert.AreEqual ("AB", s.Remove (2), "#1");
3160 Assert.AreEqual (string.Empty, s.Remove (0), "#2");
3161 Assert.AreEqual ("A", s.Remove (1), "#3");
3162 }
3163
3164 [Test]
3165 public void Replace()
3166 {
3167 string s1 = "original";
3168
3169 Assert.AreEqual (s1, s1.Replace('q', 's'), "non-hit char");
3170 Assert.AreEqual ("oxiginal", s1.Replace('r', 'x'), "single char");
3171 Assert.AreEqual ("orxgxnal", s1.Replace('i', 'x'), "double char");
3172
3173 bool errorThrown = false;
3174 try {
3175 string s = s1.Replace(null, "feh");
3176 } catch (ArgumentNullException) {
3177 errorThrown = true;
3178 }
3179 Assert.IsTrue (errorThrown, "should get null arg exception");
3180
3181 Assert.AreEqual ("ornal", s1.Replace("igi", null), "replace as remove");
3182 Assert.AreEqual (s1, s1.Replace("spam", "eggs"), "non-hit string");
3183 Assert.AreEqual ("orirumal", s1.Replace("gin", "rum"), "single string");
3184 Assert.AreEqual ("oreigeinal", s1.Replace("i", "ei"), "double string");
3185
3186 Assert.AreEqual ("ooriginal", s1.Replace("o", "oo"), "start");
3187 Assert.AreEqual ("originall", s1.Replace("l", "ll"), "end");
3188
3189 Assert.AreEqual ("riginal", s1.Replace("o", string.Empty), "start empty");
3190 Assert.AreEqual ("origina", s1.Replace("l", string.Empty), "end empty");
3191
3192 Assert.AreEqual ("original", s1.Replace("original2", "original3"), "replace bigger that original");
3193
3194 Assert.AreEqual (":!:", "::".Replace ("::", ":!:"), "result longer");
3195
3196 // Test overlapping matches (bug #54988)
3197 string s2 = "...aaaaaaa.bbbbbbbbb,............ccccccc.u...";
3198 Assert.AreEqual (s2.Replace("..", "."), "..aaaaaaa.bbbbbbbbb,......ccccccc.u..");
3199
3200 // Test replacing null characters (bug #67395)
3201 Assert.AreEqual ("is this ok ?", "is \0 ok ?".Replace ("\0", "this"), "should not strip content after nullchar");
3202 }
3203
3204 [Test]
3205 public void ReplaceStringBeginEndTest ()
3206 {
3207 string s1 = "original";
3208
3209 Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1");
3210 Assert.AreEqual ("origina", s1.Replace ("l", ""), "#2");
3211 Assert.AreEqual ("ariginal", s1.Replace ("o", "a"), "#3");
3212 Assert.AreEqual ("originaa", s1.Replace ("l", "a"), "#4");
3213 Assert.AreEqual ("aariginal", s1.Replace ("o", "aa"), "#5");
3214 Assert.AreEqual ("originaaa", s1.Replace ("l", "aa"), "#6");
3215 Assert.AreEqual ("original", s1.Replace ("o", "o"), "#7");
3216 Assert.AreEqual ("original", s1.Replace ("l", "l"), "#8");
3217 Assert.AreEqual ("original", s1.Replace ("original", "original"), "#9");
3218 Assert.AreEqual ("", s1.Replace ("original", ""), "#10");
3219 }
3220
3221 [Test]
3222 public void ReplaceStringBeginEndTestFallback ()
3223 {
3224 string prev = new String ('o', 300);
3225 string s1 = prev + "riginal";
3226
3227 Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1");
3228 Assert.AreEqual (prev + "rigina", s1.Replace ("l", ""), "#2");
3229 Assert.AreEqual (new String ('a', 300) + "riginal", s1.Replace ("o", "a"), "#3");
3230 Assert.AreEqual (prev + "riginaa", s1.Replace ("l", "a"), "#4");
3231 Assert.AreEqual (new String ('a', 600) + "riginal", s1.Replace ("o", "aa"), "#5");
3232 Assert.AreEqual (prev + "riginaaa", s1.Replace ("l", "aa"), "#6");
3233 Assert.AreEqual (s1, s1.Replace ("o", "o"), "#7");
3234 Assert.AreEqual (s1, s1.Replace ("l", "l"), "#8");
3235 Assert.AreEqual (s1, s1.Replace (s1, s1), "#9");
3236 Assert.AreEqual ("", s1.Replace (prev + "riginal", ""), "#10");
3237 }
3238
3239 [Test]
3240 public void ReplaceStringOffByOne ()
3241 {
3242 Assert.AreEqual ("", new String ('o', 199).Replace ("o", ""), "#-1");
3243 Assert.AreEqual ("", new String ('o', 200).Replace ("o", ""), "#0");
3244 Assert.AreEqual ("", new String ('o', 201).Replace ("o", ""), "#+1");
3245 }
3246
3247 [Test]
3248 public void ReplaceStringCultureTests ()
3249 {
3250 // LAMESPEC: According to MSDN Replace with String parameter is culture-senstive.
3251 // However this does not currently seem to be the case. Otherwise following code should
3252 // produce "check" instead of "AE"
3253
3254 CultureInfo old = Thread.CurrentThread.CurrentCulture;
3255 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3256 Assert.AreEqual ("AE", "AE".Replace ("\u00C6", "check"), "#1");
3257 Thread.CurrentThread.CurrentCulture = old;
3258 }
3259
3260 [Test] // StartsWith (String)
3261 public void StartsWith1 ()
3262 {
3263 string s1 = "original";
3264
3265 Assert.IsTrue (s1.StartsWith ("o"), "#1");
3266 Assert.IsTrue (s1.StartsWith ("orig"), "#2");
3267 Assert.IsTrue (!s1.StartsWith ("rig"), "#3");
3268 Assert.IsTrue (s1.StartsWith (String.Empty), "#4");
3269 Assert.IsTrue (String.Empty.StartsWith (String.Empty), "#5");
3270 Assert.IsTrue (!String.Empty.StartsWith ("rig"), "#6");
3271 }
3272
3273 [Test] // StartsWith (String)
3274 public void StartsWith1_Value_Null ()
3275 {
3276 try {
3277 "A".StartsWith (null);
3278 Assert.Fail ("#1");
3279 } catch (ArgumentNullException ex) {
3280 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3281 Assert.IsNull (ex.InnerException, "#3");
3282 Assert.IsNotNull (ex.Message, "#4");
3283 Assert.AreEqual ("value", ex.ParamName, "#5");
3284 }
3285 }
3286
3287 [Test] // StartsWith (String, StringComparison)
3288 public void StartsWith2_ComparisonType_Invalid ()
3289 {
3290 try {
3291 "ABC".StartsWith ("A", (StringComparison) 80);
3292 Assert.Fail ("#1");
3293 } catch (ArgumentException ex) {
3294 // The string comparison type passed in is currently
3295 // not supported
3296 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3297 Assert.IsNull (ex.InnerException, "#3");
3298 Assert.IsNotNull (ex.Message, "#4");
3299 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
3300 }
3301 }
3302
3303 [Test] // StartsWith (String, StringComparison)
3304 public void StartsWith2_Value_Null ()
3305 {
3306 try {
3307 "A".StartsWith (null, StringComparison.CurrentCulture);
3308 Assert.Fail ("#1");
3309 } catch (ArgumentNullException ex) {
3310 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3311 Assert.IsNull (ex.InnerException, "#3");
3312 Assert.IsNotNull (ex.Message, "#4");
3313 Assert.AreEqual ("value", ex.ParamName, "#5");
3314 }
3315 }
3316
3317 [Test] // StartsWith (String, Boolean, CultureInfo)
3318 public void StartsWith3_Culture_Null ()
3319 {
3320 // This should not crash
3321 string s = "boo";
3322
3323 s.StartsWith ("this", true, null);
3324 }
3325
3326 [Test] // SubString (Int32)
3327 public void Substring1 ()
3328 {
3329 string s = "original";
3330
3331 Assert.AreEqual ("inal", s.Substring (4), "#1");
3332 Assert.AreEqual (string.Empty, s.Substring (s.Length), "#2");
3333 Assert.AreSame (s, s.Substring (0), "#3");
3334 }
3335
3336 [Test] // SubString (Int32)
3337 public void SubString1_StartIndex_Negative ()
3338 {
3339 string s = "original";
3340
3341 try {
3342 s.Substring (-1);
3343 Assert.Fail ("#1");
3344 } catch (ArgumentOutOfRangeException ex) {
3345 // StartIndex cannot be less than zero
3346 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3347 Assert.IsNull (ex.InnerException, "#3");
3348 Assert.IsNotNull (ex.Message, "#4");
3349 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3350 }
3351 }
3352
3353 [Test] // SubString (Int32)
3354 public void SubString1_StartIndex_Overflow ()
3355 {
3356 string s = "original";
3357
3358 try {
3359 s.Substring (s.Length + 1);
3360 Assert.Fail ("#1");
3361 } catch (ArgumentOutOfRangeException ex) {
3362 // startIndex cannot be larger than length of string
3363 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3364 Assert.IsNull (ex.InnerException, "#3");
3365 Assert.IsNotNull (ex.Message, "#4");
3366 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3367 }
3368 }
3369
3370 [Test] // SubString (Int32, Int32)
3371 public void Substring2 ()
3372 {
3373 string s = "original";
3374
3375 Assert.AreEqual ("igin", s.Substring (2, 4), "#1");
3376 Assert.AreEqual (string.Empty, s.Substring (s.Length, 0), "#2");
3377 Assert.AreEqual ("origina", s.Substring (0, s.Length - 1), "#3");
3378 Assert.AreEqual (s, s.Substring (0, s.Length), "#4");
3379 Assert.AreSame (s, s.Substring (0, s.Length), "#5");
3380 }
3381
3382 [Test] // SubString (Int32, Int32)
3383 public void SubString2_Length_Negative ()
3384 {
3385 string s = "original";
3386
3387 try {
3388 s.Substring (1, -1);
3389 Assert.Fail ("#1");
3390 } catch (ArgumentOutOfRangeException ex) {
3391 // Length cannot be less than zero
3392 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3393 Assert.IsNull (ex.InnerException, "#3");
3394 Assert.IsNotNull (ex.Message, "#4");
3395 Assert.AreEqual ("length", ex.ParamName, "#5");
3396 }
3397 }
3398
3399 [Test] // SubString (Int32, Int32)
3400 public void Substring2_Length_Overflow ()
3401 {
3402 string s = "original";
3403
3404 try {
3405 s.Substring (s.Length, 1);
3406 Assert.Fail ("#A1");
3407 } catch (ArgumentOutOfRangeException ex) {
3408 // Index and length must refer to a location within
3409 // the string
3410 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3411 Assert.IsNull (ex.InnerException, "#A3");
3412 Assert.IsNotNull (ex.Message, "#A4");
3413 Assert.AreEqual ("length", ex.ParamName, "#A5");
3414 }
3415
3416 try {
3417 s.Substring (1, s.Length);
3418 Assert.Fail ("#B1");
3419 } catch (ArgumentOutOfRangeException ex) {
3420 // Index and length must refer to a location within
3421 // the string
3422 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3423 Assert.IsNull (ex.InnerException, "#B3");
3424 Assert.IsNotNull (ex.Message, "#B4");
3425 Assert.AreEqual ("length", ex.ParamName, "#B5");
3426 }
3427
3428 try {
3429 s.Substring (1, Int32.MaxValue);
3430 Assert.Fail ("#C1");
3431 } catch (ArgumentOutOfRangeException ex) {
3432 // Index and length must refer to a location within
3433 // the string
3434 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
3435 Assert.IsNull (ex.InnerException, "#C3");
3436 Assert.IsNotNull (ex.Message, "#C4");
3437 Assert.AreEqual ("length", ex.ParamName, "#C5");
3438 }
3439 }
3440
3441 [Test] // SubString (Int32, Int32)
3442 public void SubString2_StartIndex_Negative ()
3443 {
3444 string s = "original";
3445
3446 try {
3447 s.Substring (-1, 1);
3448 Assert.Fail ("#1");
3449 } catch (ArgumentOutOfRangeException ex) {
3450 // StartIndex cannot be less than zero
3451 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3452 Assert.IsNull (ex.InnerException, "#3");
3453 Assert.IsNotNull (ex.Message, "#4");
3454 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3455 }
3456 }
3457
3458 [Test] // SubString (Int32, Int32)
3459 public void Substring2_StartIndex_Overflow ()
3460 {
3461 string s = "original";
3462
3463 try {
3464 s.Substring (s.Length + 1, 0);
3465 Assert.Fail ("#A1");
3466 } catch (ArgumentOutOfRangeException ex) {
3467 // startIndex cannot be larger than length of string
3468 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3469 Assert.IsNull (ex.InnerException, "#A3");
3470 Assert.IsNotNull (ex.Message, "#A4");
3471 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3472 }
3473
3474 try {
3475 "Mono".Substring (Int32.MaxValue, 1);
3476 Assert.Fail ("#B1");
3477 } catch (ArgumentOutOfRangeException ex) {
3478 // startIndex cannot be larger than length of string
3479 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3480 Assert.IsNull (ex.InnerException, "#B3");
3481 Assert.IsNotNull (ex.Message, "#B4");
3482 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3483 }
3484 }
3485
3486 [Test]
3487 public void ToCharArray ()
3488 {
3489 const string s = "original";
3490 char [] c;
3491
3492 c = s.ToCharArray ();
3493 Assert.AreEqual (s.Length, c.Length, "#A1");
3494 Assert.AreEqual (s, new String (c), "#A2");
3495
3496 c = s.ToCharArray (0, s.Length);
3497 Assert.AreEqual (s.Length, c.Length, "#B1");
3498 Assert.AreEqual (s, new String (c), "#B2");
3499
3500 c = s.ToCharArray (1, s.Length - 1);
3501 Assert.AreEqual (7, c.Length, "#C1");
3502 Assert.AreEqual ("riginal", new String (c), "#C2");
3503
3504 c = s.ToCharArray (0, 3);
3505 Assert.AreEqual (3, c.Length, "#D1");
3506 Assert.AreEqual ("ori", new String (c), "#D2");
3507
3508 c = s.ToCharArray (2, 0);
3509 Assert.AreEqual (0, c.Length, "#E1");
3510 Assert.AreEqual (string.Empty, new String (c), "#E2");
3511
3512 c = s.ToCharArray (3, 2);
3513 Assert.AreEqual (2, c.Length, "#F1");
3514 Assert.AreEqual ("gi", new String (c), "#F2");
3515
3516 c = s.ToCharArray (s.Length, 0);
3517 Assert.AreEqual (0, c.Length, "#G1");
3518 Assert.AreEqual (string.Empty, new String (c), "#G2");
3519 }
3520
3521 [Test]
3522 public void ToCharArray_Length_Negative ()
3523 {
3524 const string s = "original";
3525
3526 try {
3527 s.ToCharArray (1, -1);
3528 Assert.Fail ("#1");
3529 } catch (ArgumentOutOfRangeException ex) {
3530 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3531 Assert.IsNull (ex.InnerException, "#3");
3532 Assert.IsNotNull (ex.Message, "#4");
3533 Assert.AreEqual ("length", ex.ParamName, "#5");
3534 }
3535 }
3536
3537 [Test]
3538 public void ToCharArray_Length_Overflow ()
3539 {
3540 const string s = "original";
3541
3542 try {
3543 s.ToCharArray (1, s.Length);
3544 Assert.Fail ("#A1");
3545 } catch (ArgumentOutOfRangeException ex) {
3546 // Index was out of range. Must be non-negative and
3547 // less than the size of the collection
3548 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3549 Assert.IsNull (ex.InnerException, "#A3");
3550 Assert.IsNotNull (ex.Message, "#A4");
3551 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3552 }
3553
3554 try {
3555 s.ToCharArray (1, Int32.MaxValue);
3556 Assert.Fail ("#B1");
3557 } catch (ArgumentOutOfRangeException ex) {
3558 // Index was out of range. Must be non-negative and
3559 // less than the size of the collection
3560 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3561 Assert.IsNull (ex.InnerException, "#B3");
3562 Assert.IsNotNull (ex.Message, "#B4");
3563 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3564 }
3565 }
3566
3567 [Test]
3568 public void ToCharArray_StartIndex_Negative ()
3569 {
3570 const string s = "original";
3571
3572 try {
3573 s.ToCharArray (-1, 1);
3574 Assert.Fail ("#1");
3575 } catch (ArgumentOutOfRangeException ex) {
3576 // Index was out of range. Must be non-negative and
3577 // less than the size of the collection
3578 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3579 Assert.IsNull (ex.InnerException, "#3");
3580 Assert.IsNotNull (ex.Message, "#4");
3581 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3582 }
3583 }
3584
3585 [Test]
3586 public void ToCharArray_StartIndex_Overflow ()
3587 {
3588 const string s = "original";
3589
3590 try {
3591 s.ToCharArray (s.Length, 1);
3592 Assert.Fail ("#A1");
3593 } catch (ArgumentOutOfRangeException ex) {
3594 // Index was out of range. Must be non-negative and
3595 // less than the size of the collection
3596 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3597 Assert.IsNull (ex.InnerException, "#A3");
3598 Assert.IsNotNull (ex.Message, "#A4");
3599 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3600 }
3601
3602 try {
3603 s.ToCharArray (Int32.MaxValue, 1);
3604 Assert.Fail ("#B1");
3605 } catch (ArgumentOutOfRangeException ex) {
3606 // Index was out of range. Must be non-negative and
3607 // less than the size of the collection
3608 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3609 Assert.IsNull (ex.InnerException, "#B3");
3610 Assert.IsNotNull (ex.Message, "#B4");
3611 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3612 }
3613 }
3614
3615 [Test] // ToLower ()
3616 public void ToLower1 ()
3617 {
3618 string s = "OrIgInAli";
3619
3620 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3621
3622 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower(), "#1");
3623
3624 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3625
3626 Assert.AreEqual ("originali", s.ToLower (), "#2");
3627 }
3628
3629 [Test] // ToLower (CultureInfo)
3630 public void ToLower2 ()
3631 {
3632 string s = "OrIgInAli";
3633
3634 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3635
3636 Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#A1");
3637 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#A2");
3638 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#A3");
3639 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#A4");
3640
3641 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3642
3643 Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#B1");
3644 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#B2");
3645 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#B3");
3646 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#B4");
3647 }
3648
3649 [Test] // ToLower (CultureInfo)
3650 public void ToLower2_Culture_Null ()
3651 {
3652 string s = "OrIgInAl";
3653
3654 try {
3655 s.ToLower ((CultureInfo) null);
3656 Assert.Fail ("#A1");
3657 } catch (ArgumentNullException ex) {
3658 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
3659 Assert.IsNull (ex.InnerException, "#A3");
3660 Assert.IsNotNull (ex.Message, "#A4");
3661 Assert.AreEqual ("culture", ex.ParamName, "#A5");
3662 }
3663
3664 try {
3665 string.Empty.ToLower ((CultureInfo) null);
3666 Assert.Fail ("#B1");
3667 } catch (ArgumentNullException ex) {
3668 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
3669 Assert.IsNull (ex.InnerException, "#B3");
3670 Assert.IsNotNull (ex.Message, "#B4");
3671 Assert.AreEqual ("culture", ex.ParamName, "#B5");
3672 }
3673 }
3674
3675 [Test]
3676 public void TestToString ()
3677 {
3678 string s1 = "OrIgInAli";
3679 Assert.AreEqual (s1, s1.ToString(), "ToString failed!");
3680 }
3681
3682 [Test] // ToUpper ()
3683 public void ToUpper1 ()
3684 {
3685 string s = "OrIgInAli";
3686
3687 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3688
3689 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (), "#1");
3690
3691 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3692
3693 Assert.AreEqual ("ORIGINALI", s.ToUpper (), "#2");
3694 }
3695
3696 [Test] // ToUpper (CultureInfo)
3697 public void ToUpper2 ()
3698 {
3699 string s = "OrIgInAli";
3700
3701 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3702
3703 Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#A1");
3704 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#A2");
3705 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#A3");
3706 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#A4");
3707
3708 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3709
3710 Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#B1");
3711 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#B2");
3712 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#B3");
3713 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#B4");
3714 }
3715
3716 [Test] // ToUpper (CultureInfo)
3717 public void ToUpper2_Culture_Null ()
3718 {
3719 string s = "OrIgInAl";
3720
3721 try {
3722 s.ToUpper ((CultureInfo) null);
3723 Assert.Fail ("#A1");
3724 } catch (ArgumentNullException ex) {
3725 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
3726 Assert.IsNull (ex.InnerException, "#A3");
3727 Assert.IsNotNull (ex.Message, "#A4");
3728 Assert.AreEqual ("culture", ex.ParamName, "#A5");
3729 }
3730
3731 try {
3732 string.Empty.ToUpper ((CultureInfo) null);
3733 Assert.Fail ("#B1");
3734 } catch (ArgumentNullException ex) {
3735 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
3736 Assert.IsNull (ex.InnerException, "#B3");
3737 Assert.IsNotNull (ex.Message, "#B4");
3738 Assert.AreEqual ("culture", ex.ParamName, "#B5");
3739 }
3740 }
3741
3742 [Test]
3743 public void TestTrim ()
3744 {
3745 string s1 = " original\t\n";
3746 Assert.AreEqual ("original", s1.Trim(), "basic trim failed");
3747 Assert.AreEqual ("original", s1.Trim(null), "basic trim failed");
3748
3749 s1 = "original";
3750 Assert.AreEqual ("original", s1.Trim(), "basic trim failed");
3751 Assert.AreEqual ("original", s1.Trim(null), "basic trim failed");
3752
3753 s1 = " \t \n ";
3754 Assert.AreEqual (string.Empty, s1.Trim(), "empty trim failed");
3755 Assert.AreEqual (string.Empty, s1.Trim(null), "empty trim failed");
3756
3757 s1 = "aaaoriginalbbb";
3758 char[] delims = {'a', 'b'};
3759 Assert.AreEqual ("original", s1.Trim(delims), "custom trim failed");
3760
3761 Assert.AreEqual ("original", "\u2028original\u2029".Trim (), "net_2_0 additional char#1");
3762 Assert.AreEqual ("original", "\u0085original\u1680".Trim (), "net_2_0 additional char#2");
3763
3764 #if NET_4_0
3765 Assert.AreEqual ("", "\x9\xa\xb\xc\xd\x20\x85\xa0\x1680\x180e\x2000\x2001\x2002\x2003\x2004\x2005\x2006\x2007\x2008\x2009\x200a\x2028\x2029\x202f\x205f\x3000".Trim (), "net_4_0 changes #1");
3766 #endif
3767 }
3768
3769 [Test]
3770 public void TestTrimEnd ()
3771 {
3772 string s1 = " original\t\n";
3773 Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed");
3774
3775 s1 = " original";
3776 Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed");
3777
3778 s1 = " \t \n \n ";
3779 Assert.AreEqual (string.Empty, s1.TrimEnd(null), "empty TrimEnd failed");
3780
3781 s1 = "aaaoriginalbbb";
3782 char[] delims = {'a', 'b'};
3783 Assert.AreEqual ("aaaoriginal", s1.TrimEnd(delims), "custom TrimEnd failed");
3784 }
3785
3786 [Test]
3787 public void TestTrimStart ()
3788 {
3789 string s1 = " original\t\n";
3790 Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed");
3791
3792 s1 = "original\t\n";
3793 Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed");
3794
3795 s1 = " \t \n \n ";
3796 Assert.AreEqual (string.Empty, s1.TrimStart(null), "empty TrimStart failed");
3797
3798 s1 = "aaaoriginalbbb";
3799 char[] delims = {'a', 'b'};
3800 Assert.AreEqual ("originalbbb", s1.TrimStart(delims), "custom TrimStart failed");
3801 }
3802
3803 [Test]
3804 public void TestChars ()
3805 {
3806 string s;
3807
3808 s = string.Empty;
3809 try {
3810 char c = s [0];
3811 Assert.Fail ("#A1:" + c);
3812 } catch (IndexOutOfRangeException ex) {
3813 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
3814 Assert.IsNull (ex.InnerException, "#A3");
3815 Assert.IsNotNull (ex.Message, "#A4");
3816 }
3817
3818 s = "A";
3819 try {
3820 char c = s [-1];
3821 Assert.Fail ("#B1:" + c);
3822 } catch (IndexOutOfRangeException ex) {
3823 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
3824 Assert.IsNull (ex.InnerException, "#B3");
3825 Assert.IsNotNull (ex.Message, "#B4");
3826 }
3827 }
3828
3829 [Test]
3830 public void TestComparePeriod ()
3831 {
3832 // according to bug 63981, this behavior is for all cultures
3833 Assert.AreEqual (-1, String.Compare ("foo.obj", "foobar.obj", false), "#1");
3834 }
3835
3836 [Test]
3837 public void LastIndexOfAnyBounds1 ()
3838 {
3839 string mono = "Mono";
3840 char [] k = { 'M' };
3841 try {
3842 mono.LastIndexOfAny (k, mono.Length, 1);
3843 Assert.Fail ("#1");
3844 } catch (ArgumentOutOfRangeException ex) {
3845 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3846 Assert.IsNull (ex.InnerException, "#3");
3847 Assert.IsNotNull (ex.Message, "#4");
3848 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3849 }
3850 }
3851
3852 [Test]
3853 public void TestSplit ()
3854 {
3855 string s1 = "abcdefghijklm";
3856 char[] c1 = {'q', 'r'};
3857 Assert.AreEqual (s1, (s1.Split(c1))[0], "No splitters");
3858
3859 char[] c2 = {'a', 'e', 'i', 'o', 'u'};
3860 string[] chunks = s1.Split(c2);
3861 Assert.AreEqual (string.Empty, chunks[0], "First chunk");
3862 Assert.AreEqual ("bcd", chunks[1], "Second chunk");
3863 Assert.AreEqual ("fgh", chunks[2], "Third chunk");
3864 Assert.AreEqual ("jklm", chunks[3], "Fourth chunk");
3865
3866 {
3867 bool errorThrown = false;
3868 try {
3869 chunks = s1.Split(c2, -1);
3870 } catch (ArgumentOutOfRangeException) {
3871 errorThrown = true;
3872 }
3873 Assert.IsTrue (errorThrown, "Split out of range");
3874 }
3875
3876 chunks = s1.Split(c2, 2);
3877 Assert.AreEqual (2, chunks.Length, "Limited chunk");
3878 Assert.AreEqual (string.Empty, chunks[0], "First limited chunk");
3879 Assert.AreEqual ("bcdefghijklm", chunks[1], "Second limited chunk");
3880
3881 string s3 = "1.0";
3882 char[] c3 = {'.'};
3883 chunks = s3.Split(c3,2);
3884 Assert.AreEqual (2, chunks.Length, "1.0 split length");
3885 Assert.AreEqual ("1", chunks[0], "1.0 split first chunk");
3886 Assert.AreEqual ("0", chunks[1], "1.0 split second chunk");
3887
3888 string s4 = "1.0.0";
3889 char[] c4 = {'.'};
3890 chunks = s4.Split(c4,2);
3891 Assert.AreEqual (2, chunks.Length, "1.0.0 split length");
3892 Assert.AreEqual ("1", chunks[0], "1.0.0 split first chunk");
3893 Assert.AreEqual ("0.0", chunks[1], "1.0.0 split second chunk");
3894
3895 string s5 = ".0.0";
3896 char[] c5 = {'.'};
3897 chunks = s5.Split (c5, 2);
3898 Assert.AreEqual (2, chunks.Length, ".0.0 split length");
3899 Assert.AreEqual (string.Empty, chunks[0], ".0.0 split first chunk");
3900 Assert.AreEqual ("0.0", chunks[1], ".0.0 split second chunk");
3901
3902 string s6 = ".0";
3903 char[] c6 = {'.'};
3904 chunks = s6.Split (c6, 2);
3905 Assert.AreEqual (2, chunks.Length, ".0 split length");
3906 Assert.AreEqual (string.Empty, chunks[0], ".0 split first chunk");
3907 Assert.AreEqual ("0", chunks[1], ".0 split second chunk");
3908
3909 string s7 = "0.";
3910 char[] c7 = {'.'};
3911 chunks = s7.Split (c7, 2);
3912 Assert.AreEqual (2, chunks.Length, "0. split length");
3913 Assert.AreEqual ("0", chunks[0], "0. split first chunk");
3914 Assert.AreEqual (string.Empty, chunks[1], "0. split second chunk");
3915
3916 string s8 = "0.0000";
3917 char[] c8 = {'.'};
3918 chunks = s8.Split (c8, 2);
3919 Assert.AreEqual (2, chunks.Length, "0.0000/2 split length");
3920 Assert.AreEqual ("0", chunks[0], "0.0000/2 split first chunk");
3921 Assert.AreEqual ("0000", chunks[1], "0.0000/2 split second chunk");
3922
3923 chunks = s8.Split (c8, 3);
3924 Assert.AreEqual (2, chunks.Length, "0.0000/3 split length");
3925 Assert.AreEqual ("0", chunks[0], "0.0000/3 split first chunk");
3926 Assert.AreEqual ("0000", chunks[1], "0.0000/3 split second chunk");
3927
3928 chunks = s8.Split (c8, 1);
3929 Assert.AreEqual (1, chunks.Length, "0.0000/1 split length");
3930 Assert.AreEqual ("0.0000", chunks[0], "0.0000/1 split first chunk");
3931
3932 chunks = s1.Split(c2, 1);
3933 Assert.AreEqual (1, chunks.Length, "Single split");
3934 Assert.AreEqual (s1, chunks[0], "Single chunk");
3935
3936 chunks = s1.Split(c2, 0);
3937 Assert.AreEqual (0, chunks.Length, "Zero split");
3938
3939 #if NET_4_0
3940 Assert.AreEqual (0, "\x9\xa\xb\xc\xd\x20\x85\xa0\x1680\x180e\x2000\x2001\x2002\x2003\x2004\x2005\x2006\x2007\x2008\x2009\x200a\x2028\x2029\x202f\x205f\x3000".Split ((char[]) null, StringSplitOptions.RemoveEmptyEntries).Length, "net_4_0 changes");
3941 #endif
3942 }
3943
3944 [Test]
3945 public void MoreSplit ()
3946 {
3947 string test = "123 456 789";
3948 string [] st = test.Split ();
3949 Assert.AreEqual ("123", st [0], "#01");
3950 st = test.Split (null);
3951 Assert.AreEqual ("123", st [0], "#02");
3952
3953 Assert.AreEqual (1, "encyclopædia".Split (new[] { "ae" }, StringSplitOptions.None).Length, "#03");
3954 }
3955
3956 [Test] // Split (Char [], StringSplitOptions)
3957 public void Split3_Options_Invalid ()
3958 {
3959 try {
3960 "A B".Split (new Char [] { 'A' }, (StringSplitOptions) 4096);
3961 Assert.Fail ("#1");
3962 } catch (ArgumentException ex) {
3963 // Illegal enum value: 4096
3964 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3965 Assert.IsNull (ex.InnerException, "#3");
3966 Assert.IsNotNull (ex.Message, "#4");
3967 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3968 Assert.IsNull (ex.ParamName, "#6");
3969 }
3970 }
3971
3972 [Test] // Split (Char [], StringSplitOptions)
3973 public void Split4_Options_Invalid ()
3974 {
3975 try {
3976 "A B".Split (new String [] { "A" }, (StringSplitOptions) 4096);
3977 Assert.Fail ("#1");
3978 } catch (ArgumentException ex) {
3979 // Illegal enum value: 4096
3980 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3981 Assert.IsNull (ex.InnerException, "#3");
3982 Assert.IsNotNull (ex.Message, "#4");
3983 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3984 Assert.IsNull (ex.ParamName, "#6");
3985 }
3986 }
3987
3988 [Test] // Split (Char [], StringSplitOptions)
3989 public void Split5_Options_Invalid ()
3990 {
3991 try {
3992 "A B".Split (new Char [] { 'A' }, 0, (StringSplitOptions) 4096);
3993 Assert.Fail ("#1");
3994 } catch (ArgumentException ex) {
3995 // Illegal enum value: 4096
3996 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3997 Assert.IsNull (ex.InnerException, "#3");
3998 Assert.IsNotNull (ex.Message, "#4");
3999 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
4000 Assert.IsNull (ex.ParamName, "#6");
4001 }
4002 }
4003
4004 [Test] // Split (String [], Int32, StringSplitOptions)
4005 public void Split6_Count_Negative ()
4006 {
4007 try {
4008 "A B".Split (new String [] { "A" }, -1, StringSplitOptions.None);
4009 Assert.Fail ("#1");
4010 } catch (ArgumentOutOfRangeException ex) {
4011 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
4012 Assert.IsNull (ex.InnerException, "#3");
4013 Assert.IsNotNull (ex.Message, "#4");
4014 Assert.AreEqual ("count", ex.ParamName, "#5");
4015 }
4016 }
4017
4018 [Test] // Split (String [], Int32, StringSplitOptions)
4019 public void Split6_Options_Invalid ()
4020 {
4021 try {
4022 "A B".Split (new String [] { "A" }, 0, (StringSplitOptions) 4096);
4023 Assert.Fail ("#1");
4024 } catch (ArgumentException ex) {
4025 // Illegal enum value: 4096
4026 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
4027 Assert.IsNull (ex.InnerException, "#3");
4028 Assert.IsNotNull (ex.Message, "#4");
4029 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
4030 Assert.IsNull (ex.ParamName, "#6");
4031 }
4032 }
4033
4034 [Test]
4035 public void SplitString ()
4036 {
4037 String[] res;
4038
4039 // count == 0
4040 res = "A B C".Split (new String [] { "A" }, 0, StringSplitOptions.None);
4041 Assert.AreEqual (0, res.Length);
4042
4043 // empty and RemoveEmpty
4044 res = string.Empty.Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries);
4045 Assert.AreEqual (0, res.Length);
4046
4047 // Not found
4048 res = "A B C".Split (new String [] { "D" }, StringSplitOptions.None);
4049 Assert.AreEqual (1, res.Length);
4050 Assert.AreEqual ("A B C", res [0]);
4051
4052 // A normal test
4053 res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.None);
4054 Assert.AreEqual (4, res.Length);
4055 Assert.AreEqual ("A ", res [0]);
4056 Assert.AreEqual (" C ", res [1]);
4057 Assert.AreEqual (string.Empty, res [2]);
4058 Assert.AreEqual (" E", res [3]);
4059
4060 // Same with RemoveEmptyEntries
4061 res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.RemoveEmptyEntries);
4062 Assert.AreEqual (3, res.Length);
4063 Assert.AreEqual ("A ", res [0]);
4064 Assert.AreEqual (" C ", res [1]);
4065 Assert.AreEqual (" E", res [2]);
4066
4067 // Delimiter matches once at the beginning of the string
4068 res = "A B".Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries);
4069 Assert.AreEqual (1, res.Length);
4070 Assert.AreEqual (" B", res [0]);
4071
4072 // Delimiter at the beginning and at the end
4073 res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.None);
4074 Assert.AreEqual (3, res.Length);
4075 Assert.AreEqual (string.Empty, res [0]);
4076 Assert.AreEqual (" C DD ", res [1]);
4077 Assert.AreEqual (string.Empty, res [2]);
4078
4079 res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.RemoveEmptyEntries);
4080 Assert.AreEqual (1, res.Length);
4081 Assert.AreEqual (" C DD ", res [0]);
4082
4083 // count
4084 res = "A B C DD E".Split (new String[] { "B", "D" }, 2, StringSplitOptions.None);
4085 Assert.AreEqual (2, res.Length);
4086 Assert.AreEqual ("A ", res [0]);
4087 Assert.AreEqual (" C DD E", res [1]);
4088
4089 // Ordering
4090 res = "ABCDEF".Split (new String[] { "EF", "BCDE" }, StringSplitOptions.None);
4091 Assert.AreEqual (2, res.Length);
4092 Assert.AreEqual ("A", res [0]);
4093 Assert.AreEqual ("F", res [1]);
4094
4095 res = "ABCDEF".Split (new String[] { "BCD", "BC" }, StringSplitOptions.None);
4096 Assert.AreEqual (2, res.Length);
4097 Assert.AreEqual ("A", res [0]);
4098 Assert.AreEqual ("EF", res [1]);
4099
4100 // Whitespace
4101 res = "A B\nC".Split ((String[])null, StringSplitOptions.None);
4102 Assert.AreEqual (3, res.Length);
4103 Assert.AreEqual ("A", res [0]);
4104 Assert.AreEqual ("B", res [1]);
4105 Assert.AreEqual ("C", res [2]);
4106
4107 res = "A B\nC".Split (new String [0], StringSplitOptions.None);
4108 Assert.AreEqual (3, res.Length);
4109 Assert.AreEqual ("A", res [0]);
4110 Assert.AreEqual ("B", res [1]);
4111 Assert.AreEqual ("C", res [2]);
4112 }
4113
4114 [Test]
4115 public void SplitStringChars ()
4116 {
4117 String[] res;
4118
4119 // empty
4120 res = string.Empty.Split (new Char [] { 'A' });
4121 Assert.AreEqual (1, res.Length);
4122 Assert.AreEqual (string.Empty, res [0]);
4123
4124 // empty and RemoveEmpty
4125 res = string.Empty.Split (new Char [] { 'A' }, StringSplitOptions.RemoveEmptyEntries);
4126 Assert.AreEqual (0, res.Length);
4127
4128 // count == 0
4129 res = "..A..B..".Split (new Char[] { '.' }, 0, StringSplitOptions.None);
4130 Assert.AreEqual (0, res.Length, "#01-01");
4131
4132 // count == 1
4133 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.None);
4134 Assert.AreEqual (1, res.Length, "#02-01");
4135 Assert.AreEqual ("..A..B..", res [0], "#02-02");
4136
4137 // count == 1 + RemoveEmpty
4138 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries);
4139 Assert.AreEqual (1, res.Length, "#03-01");
4140 Assert.AreEqual ("..A..B..", res [0], "#03-02");
4141
4142 // Strange Case A+B A
4143 res = "...".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries);
4144 Assert.AreEqual (1, res.Length, "#ABA-01");
4145 Assert.AreEqual ("...", res [0], "#ABA-02");
4146
4147 // Strange Case A+B B
4148 res = "...".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4149 Assert.AreEqual (0, res.Length, "#ABB-01");
4150
4151 // Keeping Empties and multipe split chars
4152 res = "..A;.B.;".Split (new Char[] { '.', ';' }, StringSplitOptions.None);
4153 Assert.AreEqual (7, res.Length, "#04-01");
4154 Assert.AreEqual (string.Empty, res [0], "#04-02");
4155 Assert.AreEqual (string.Empty, res [1], "#04-03");
4156 Assert.AreEqual ("A", res [2], "#04-04");
4157 Assert.AreEqual (string.Empty, res [3], "#04-05");
4158 Assert.AreEqual ("B", res [4], "#04-06");
4159 Assert.AreEqual (string.Empty, res [5], "#04-07");
4160 Assert.AreEqual (string.Empty, res [6], "#04-08");
4161
4162 // Trimming (3 tests)
4163 res = "..A".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4164 Assert.AreEqual (1, res.Length, "#05-01");
4165 Assert.AreEqual ("A", res [0], "#05-02");
4166
4167 res = "A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4168 Assert.AreEqual (1, res.Length, "#06-01");
4169 Assert.AreEqual ("A", res [0], "#06-02");
4170
4171 res = "..A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4172 Assert.AreEqual (1, res.Length, "#07-01");
4173 Assert.AreEqual ("A", res [0], "#07-02");
4174
4175 // Lingering Tail
4176 res = "..A..B..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4177 Assert.AreEqual (2, res.Length, "#08-01");
4178 Assert.AreEqual ("A", res [0], "#08-02");
4179 Assert.AreEqual ("B..", res [1], "#08-03");
4180
4181 // Whitespace and Long split chain (removing empty chars)
4182 res = " A\tBC\n\rDEF GHI ".Split ((Char[])null, StringSplitOptions.RemoveEmptyEntries);
4183 Assert.AreEqual (4, res.Length, "#09-01");
4184 Assert.AreEqual ("A", res [0], "#09-02");
4185 Assert.AreEqual ("BC", res [1], "#09-03");
4186 Assert.AreEqual ("DEF", res [2], "#09-04");
4187 Assert.AreEqual ("GHI", res [3], "#09-05");
4188
4189 // Nothing but separators
4190 res = "..,.;.,".Split (new Char[]{'.',',',';'},2,StringSplitOptions.RemoveEmptyEntries);
4191 Assert.AreEqual (0, res.Length, "#10-01");
4192
4193 // Complete testseries
4194 char[] dash = new Char[] { '/' };
4195 StringSplitOptions o = StringSplitOptions.RemoveEmptyEntries;
4196 Assert.AreEqual ("hi", "hi".Split (dash, o)[0], "#11-01");
4197 Assert.AreEqual ("hi", "hi/".Split (dash, o)[0], "#11-02");
4198 Assert.AreEqual ("hi", "/hi".Split (dash, o)[0], "#11-03");
4199
4200 Assert.AreEqual ("hi..", "hi../".Split (dash, o)[0], "#11-04-1");
4201 Assert.AreEqual ("hi..", "/hi..".Split (dash, o)[0], "#11-04-2");
4202
4203 res = "/hi/..".Split (dash, o);
4204 Assert.AreEqual ("hi", res[0], "#11-05-1");
4205 Assert.AreEqual ("..", res[1], "#11-05-2");
4206 Assert.AreEqual (2, res.Length, "#11-09-3");
4207
4208 res = "hi/..".Split (dash, o);
4209 Assert.AreEqual ("hi", res[0], "#11-06-1");
4210 Assert.AreEqual ("..", res[1], "#11-06-2");
4211 Assert.AreEqual (2, res.Length, "#11-09-3");
4212
4213 res = "hi/../".Split (dash, o);
4214 Assert.AreEqual ("hi", res[0], "#11-07-1");
4215 Assert.AreEqual ("..", res[1], "#11-07-2");
4216 Assert.AreEqual (2, res.Length, "#11-07-3");
4217
4218 res = "/hi../".Split (dash, o);
4219 Assert.AreEqual ("hi..", res[0], "#11-08-1");
4220 Assert.AreEqual (1, res.Length, "#11-08-2");
4221
4222 res = "/hi/../".Split (dash, o);
4223 Assert.AreEqual ("hi", res[0], "#11-09-1");
4224 Assert.AreEqual ("..", res[1], "#11-09-2");
4225 Assert.AreEqual (2, res.Length, "#11-09-3");
4226
4227 Assert.AreEqual (0, " ".Split ((char[]) null, 2, StringSplitOptions.RemoveEmptyEntries).Length, "#12-00-0");
4228
4229 res = "not found".Split (new char[2]);
4230 Assert.AreEqual ("not found", res[0], "#12-04-27");
4231 Assert.AreEqual (1, res.Length, "#12-04-27-A");
4232 }
4233
4234 [Test]
4235 public void SplitStringStrings ()
4236 {
4237 String[] res;
4238
4239 // count == 0
4240 res = "..A..B..".Split (new String[] { "." }, 0, StringSplitOptions.None);
4241 Assert.AreEqual (0, res.Length, "#01-01");
4242
4243 // count == 1
4244 res = "..A..B..".Split (new String[] { "." }, 1, StringSplitOptions.None);
4245 Assert.AreEqual (1, res.Length, "#02-01");
4246 Assert.AreEqual ("..A..B..", res [0], "#02-02");
4247
4248 // count == 1 + RemoveEmpty
4249 res = "..A..B..".Split (new String[] { "." }, 1, StringSplitOptions.RemoveEmptyEntries);
4250 Assert.AreEqual (1, res.Length, "#03-01");
4251 Assert.AreEqual ("..A..B..", res [0], "#03-02");
4252
4253 // Strange Case A+B A
4254 res = "...".Split (new String[] { "." }, 1, StringSplitOptions.RemoveEmptyEntries);
4255 Assert.AreEqual (1, res.Length, "#ABA-01");
4256 Assert.AreEqual ("...", res [0], "#ABA-02");
4257
4258 // Strange Case A+B B
4259 res = "...".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4260 Assert.AreEqual (0, res.Length, "#ABB-01");
4261
4262 // Keeping Empties and multipe split chars
4263 res = "..A;.B.;".Split (new String[] { ".", ";" }, StringSplitOptions.None);
4264 Assert.AreEqual (7, res.Length, "#04-01");
4265 Assert.AreEqual (string.Empty, res [0], "#04-02");
4266 Assert.AreEqual (string.Empty, res [1], "#04-03");
4267 Assert.AreEqual ("A", res [2], "#04-04");
4268 Assert.AreEqual (string.Empty, res [3], "#04-05");
4269 Assert.AreEqual ("B", res [4], "#04-06");
4270 Assert.AreEqual (string.Empty, res [5], "#04-07");
4271 Assert.AreEqual (string.Empty, res [6], "#04-08");
4272
4273 // Trimming (3 tests)
4274 res = "..A".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4275 Assert.AreEqual (1, res.Length, "#05-01");
4276 Assert.AreEqual ("A", res [0], "#05-02");
4277
4278 res = "A..".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4279 Assert.AreEqual (1, res.Length, "#06-01");
4280 Assert.AreEqual ("A", res [0], "#06-02");
4281
4282 res = "..A..".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4283 Assert.AreEqual (1, res.Length, "#07-01");
4284 Assert.AreEqual ("A", res [0], "#07-02");
4285
4286 // Lingering Tail
4287 res = "..A..B..".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4288 Assert.AreEqual (2, res.Length, "#08-01");
4289 Assert.AreEqual ("A", res [0], "#08-02");
4290 Assert.AreEqual ("B..", res [1], "#08-03");
4291
4292 // Whitespace and Long split chain (removing empty chars)
4293 res = " A\tBC\n\rDEF GHI ".Split ((String[])null, StringSplitOptions.RemoveEmptyEntries);
4294 Assert.AreEqual (4, res.Length, "#09-01");
4295 Assert.AreEqual ("A", res [0], "#09-02");
4296 Assert.AreEqual ("BC", res [1], "#09-03");
4297 Assert.AreEqual ("DEF", res [2], "#09-04");
4298 Assert.AreEqual ("GHI", res [3], "#09-05");
4299
4300 // Nothing but separators
4301 res = "..,.;.,".Split (new String[]{".",",",";"},2,StringSplitOptions.RemoveEmptyEntries);
4302 Assert.AreEqual (0, res.Length, "#10-01");
4303
4304 // Complete testseries
4305 String[] dash = new String[] { "/" };
4306 StringSplitOptions o = StringSplitOptions.RemoveEmptyEntries;
4307 Assert.AreEqual ("hi", "hi".Split (dash, o)[0], "#11-01");
4308 Assert.AreEqual ("hi", "hi/".Split (dash, o)[0], "#11-02");
4309 Assert.AreEqual ("hi", "/hi".Split (dash, o)[0], "#11-03");
4310
4311 Assert.AreEqual ("hi..", "hi../".Split (dash, o)[0], "#11-04-1");
4312 Assert.AreEqual ("hi..", "/hi..".Split (dash, o)[0], "#11-04-2");
4313
4314 res = "/hi/..".Split (dash, o);
4315 Assert.AreEqual ("hi", res[0], "#11-05-1");
4316 Assert.AreEqual ("..", res[1], "#11-05-2");
4317 Assert.AreEqual (2, res.Length, "#11-09-3");
4318
4319 res = "hi/..".Split (dash, o);
4320 Assert.AreEqual ("hi", res[0], "#11-06-1");
4321 Assert.AreEqual ("..", res[1], "#11-06-2");
4322 Assert.AreEqual (2, res.Length, "#11-09-3");
4323
4324 res = "hi/../".Split (dash, o);
4325 Assert.AreEqual ("hi", res[0], "#11-07-1");
4326 Assert.AreEqual ("..", res[1], "#11-07-2");
4327 Assert.AreEqual (2, res.Length, "#11-07-3");
4328
4329 res = "/hi../".Split (dash, o);
4330 Assert.AreEqual ("hi..", res[0], "#11-08-1");
4331 Assert.AreEqual (1, res.Length, "#11-08-2");
4332
4333 res = "/hi/../".Split (dash, o);
4334 Assert.AreEqual ("hi", res[0], "#11-09-1");
4335 Assert.AreEqual ("..", res[1], "#11-09-2");
4336 Assert.AreEqual (2, res.Length, "#11-09-3");
4337 }
4338
4339 [Test]
4340 [Category ("NotDotNet")]
4341 public void Normalize1 ()
4342 {
4343 // .NET does not combine them into U+1F80
4344 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u03B1\u0313\u0345
4345 string s = "\u03B1\u0313\u0345";
4346 Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormC), "#1");
4347 Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormKC), "#2");
4348 Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormC), "#3");
4349 Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormKC), "#4");
4350 }
4351
4352 [Test]
4353 [Category ("NotDotNet")]
4354 public void Normalize2 ()
4355 {
4356 string s1 = "\u0061\u0301bc";
4357 string s2 = "\u00e1bc";
4358 // .NET does not combine \u0061\0301 into \u00E1
4359 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u0061\u0301bc
4360 Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormC), "#1");
4361 Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormKC), "#2");
4362 }
4363
4364 [Test]
4365 public void Normalize3 ()
4366 {
4367 var s = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0654', '\u0652', '\u064A', '\u064F', '\u0648', '\u0654' });
4368
4369 var formC = new string (new char [] { '\u064A', '\u064F', '\u0624', '\u0652', '\u064a', '\u064f', '\u0624' });
4370 var formD = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0652', '\u0654', '\u064a', '\u064f', '\u0648', '\u0654' });
4371 var formKC = new string (new char [] { '\u064A', '\u064F', '\u0624', '\u0652', '\u064a', '\u064f', '\u0624' });
4372 var formKD = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0652', '\u0654', '\u064a', '\u064f', '\u0648', '\u0654' });
4373
4374 Assert.AreEqual (formD, s.Normalize (NormalizationForm.FormD), "#1");
4375 Assert.AreEqual (formC, s.Normalize (NormalizationForm.FormC), "#2");
4376 Assert.AreEqual (formKD, s.Normalize (NormalizationForm.FormKD), "#3");
4377 Assert.AreEqual (formKC, s.Normalize (NormalizationForm.FormKC), "#4");
4378 }
4379
4380 [Test] // bug #480152, test cases by David Mitchell
4381 public void NormalizeFormD ()
4382 {
4383 Assert.AreEqual ("\u212B".Normalize (NormalizationForm.FormD), "\u0041\u030A", "#1");
4384 Assert.AreEqual ("\u1E69".Normalize (NormalizationForm.FormD), "\u0073\u0323\u0307", "#2");
4385 Assert.AreEqual ("\u1e4e".Normalize (NormalizationForm.FormD), "\u004f\u0303\u0308", "#3");
4386 Assert.AreEqual ("\u1e2f".Normalize (NormalizationForm.FormD), "\u0069\u0308\u0301", "#4");
4387 }
4388
4389 [Test] // bug #480152, test cases by David Mitchell
4390 public void NormalizeFormC ()
4391 {
4392 Assert.AreEqual ("\u0041\u030a\u0061\u030a".Normalize (NormalizationForm.FormC), "\u00c5\u00e5", "#1");
4393 Assert.AreEqual ("\u006E\u0303".Normalize (NormalizationForm.FormC), "\u00F1", "#2");
4394 Assert.AreEqual ("\u03B7\u0313\u0300\u0345".Normalize (NormalizationForm.FormC), "\u1F92", "#3");
4395 }
4396
4397 [Test] // bug #480152, test cases by Tom Philpot
4398 public void NormalizeFormCCrashers ()
4399 {
4400 string[][] entries = new string[][] {
4401 new string[] { "\u05d0\u0307\u05dc", "#1" },
4402 new string[] { "\u05d0\u0307\u05dc\u05d9\u05d9\u05df", "#2" },
4403 new string[] { "\u05d4\u05d0\u0307\u05dc\u0307\u05d9\u0307\u05df\u0307", "#3" },
4404 new string[] { "\u05d9\u05e9\u05de\u05e2\u0307\u05d0\u0307\u05dc\u0307", "#4" },
4405 new string[] { "\u05d9\u05e9\u05e8\u05d0\u0307\u05dc\u0307", "#5" },
4406 };
4407
4408 foreach (string[] entry in entries)
4409 entry [0].Normalize (NormalizationForm.FormC);
4410 }
4411
4412 [Test]
4413 public void NormalizeFormCHangul ()
4414 {
4415 Assert.AreEqual ("\u1100\u116C".Normalize (NormalizationForm.FormC), "\uAD34", "#1");
4416 Assert.AreEqual ("\u1100\u116B\u11C2".Normalize (NormalizationForm.FormC), "\uAD33", "#2");
4417 Assert.AreEqual ("\u1100!".Normalize (NormalizationForm.FormC), "\u1100!", "#3");
4418 Assert.AreEqual ("\u1100\u116B!".Normalize (NormalizationForm.FormC), "\uAD18\u0021", "#4");
4419 Assert.AreEqual ("!\u116C".Normalize (NormalizationForm.FormC), "!\u116C", "#5");
4420 Assert.AreEqual ("!\u116B\u11C2".Normalize (NormalizationForm.FormC), "!\u116B\u11C2", "#6");
4421 }
4422
4423 [Test]
4424 public void MoreNormalizeFormC ()
4425 {
4426 Assert.AreEqual ("\u1E0A\u0323".Normalize (NormalizationForm.FormC), "\u1E0C\u0307", "#1");
4427 Assert.AreEqual ("\u0044\u0323\u0307".Normalize (NormalizationForm.FormC), "\u1E0C\u0307", "#2");
4428 }
4429
4430 [Test]
4431 public void Emptiness ()
4432 {
4433 // note: entries using AreEqual are in reality AreNotSame on MS FX
4434 // but I prefer Mono implementation ;-) and it minimize the changes
4435 Assert.AreSame (String.Empty, "", "Empty");
4436
4437 Assert.AreSame (String.Empty, String.Concat ((object) null), "Concat(null)");
4438 Assert.AreSame (String.Empty, String.Concat ((object) String.Empty), "Concat(empty)");
4439 Assert.AreSame (String.Empty, String.Concat ((object) String.Empty, (object) String.Empty), "Concat(object,object)");
4440 Assert.AreSame (String.Empty, String.Concat (String.Empty, String.Empty), "Concat(string,string)");
4441 Assert.AreEqual (String.Empty, String.Concat (String.Empty, String.Empty, String.Empty), "Concat(string,string,string)");
4442 Assert.AreEqual (String.Empty, String.Concat ((object) null, (object) (object) null, (object) null, (object) null), "Concat(null,null,null,null)-object");
4443 Assert.AreSame (String.Empty, String.Concat ((string) null, (string) (string) null, (string) null, (string) null), "Concat(null,null,null,null)-string");
4444 Assert.AreNotSame (String.Empty, String.Concat (String.Empty, String.Empty, String.Empty, String.Empty), "Concat(string,string,string,string)");
4445 Assert.AreEqual (String.Empty, String.Concat (new object [] { String.Empty, String.Empty }), "Concat(object[])");
4446 Assert.AreEqual (String.Empty, String.Concat (new string [] { String.Empty, String.Empty }), "Concat(string[])");
4447
4448 Assert.AreNotSame (String.Empty, String.Copy (String.Empty), "Copy");
4449
4450 Assert.AreEqual (String.Empty, "".Insert (0, String.Empty), "Insert(Empty)");
4451 Assert.AreEqual (String.Empty, String.Empty.Insert (0, ""), "Empty.Insert");
4452
4453 Assert.AreSame (String.Empty, String.Empty.PadLeft (0), "PadLeft(int)");
4454 Assert.AreSame (String.Empty, String.Empty.PadLeft (0, '.'), "PadLeft(int.char)");
4455 Assert.AreSame (String.Empty, String.Empty.PadRight (0), "PadRight(int)");
4456 Assert.AreSame (String.Empty, String.Empty.PadRight (0, '.'), "PadRight(int.char)");
4457
4458 Assert.AreSame (String.Empty, "".Substring (0), "Substring(int)");
4459 Assert.AreSame (String.Empty, "ab".Substring (1, 0), "Substring(int,int)");
4460
4461 Assert.AreSame (String.Empty, "".ToLower (), "ToLower");
4462 Assert.AreSame (String.Empty, "".ToUpper (), "ToUpper");
4463 Assert.AreSame (String.Empty, "".ToLower (CultureInfo.CurrentCulture), "ToLower(CultureInfo)");
4464 Assert.AreSame (String.Empty, "".ToUpper (CultureInfo.CurrentCulture), "ToUpper(CultureInfo)");
4465 Assert.AreSame (String.Empty, "".ToLowerInvariant (), "ToLowerInvariant");
4466 Assert.AreSame (String.Empty, "".ToUpperInvariant (), "ToUpperInvariant");
4467
4468 Assert.AreSame (String.Empty, "".Trim (), "Trim()");
4469 Assert.AreSame (String.Empty, "a".Trim ('a'), "Trim(char)");
4470 Assert.AreSame (String.Empty, "a".TrimEnd ('a'), "TrimEnd(char)");
4471 Assert.AreSame (String.Empty, "a".TrimStart ('a'), "TrimStart(char)");
4472 }
4473
4474 [Test]
4475 public void LastIndexOfAndEmptiness () {
4476 Assert.AreEqual (-1, "".LastIndexOf('.'), "#1");
4477 Assert.AreEqual (-1, "".LastIndexOf('.', -1), "#2");
4478 Assert.AreEqual (-1, "".LastIndexOf('.', -1, -1), "#3");
4479 Assert.AreEqual (0, "x".LastIndexOf('x', 0), "#4");
4480 Assert.AreEqual (0 , "x".LastIndexOf('x', 0, 1), "#5");
4481 Assert.AreEqual (-1 , "x".LastIndexOf('z', 0, 1), "#6");
4482
4483 try {
4484 "".LastIndexOf(null);
4485 Assert.Fail ("#7");
4486 } catch (ArgumentNullException) {}
4487
4488 Assert.AreEqual (0, "".LastIndexOf(""), "#8");
4489 Assert.AreEqual (0, "".LastIndexOf("", -1), "#9");
4490 Assert.AreEqual (0, "".LastIndexOf("", -1, 1), "#10");
4491 Assert.AreEqual (0, "".LastIndexOf("", StringComparison.Ordinal), "#11");
4492 Assert.AreEqual (0, "".LastIndexOf("", -1, StringComparison.Ordinal), "#12");
4493 Assert.AreEqual (0, "".LastIndexOf("", -1, -1, StringComparison.Ordinal), "#13");
4494 Assert.AreEqual (0, "x".LastIndexOf(""), "#14");
4495
4496 Assert.AreEqual (0, "x".LastIndexOf("x", 0), "#15");
4497 Assert.AreEqual (0, "x".LastIndexOf("", 0), "#16");
4498 Assert.AreEqual (0, "xxxx".LastIndexOf("", 0), "#17");
4499 Assert.AreEqual (1, "xxxx".LastIndexOf("", 1), "#18");
4500
4501 Assert.AreEqual (1, "xy".LastIndexOf(""), "#19");
4502 Assert.AreEqual (2, "xyz".LastIndexOf(""), "#20");
4503 Assert.AreEqual (1, "xy".LastIndexOf(""), "#21");
4504 Assert.AreEqual (1, "xy".LastIndexOf("", 2), "#22");
4505 Assert.AreEqual (2, "xyz".LastIndexOf("", 2), "#23");
4506 Assert.AreEqual (2, "xyz".LastIndexOf("", 2, 2), "#24");
4507 Assert.AreEqual (2, "xyz".LastIndexOf("", 3, 3), "#25");
4508
4509 try {
4510 "xy".LastIndexOf("", 29);
4511 Assert.Fail ("#26");
4512 }catch (ArgumentOutOfRangeException){}
4513
4514 Assert.AreEqual (-1, "".LastIndexOf("x"), "#27");
4515 Assert.AreEqual (-1, "".LastIndexOf("x", -1), "#28");
4516 Assert.AreEqual (-1, "".LastIndexOf("x", -1), "#29");
4517 Assert.AreEqual (-1, "".LastIndexOf("x", StringComparison.Ordinal), "#30");
4518 Assert.AreEqual (-1, "".LastIndexOf("x", -1, StringComparison.Ordinal), "#31");
4519 Assert.AreEqual (-1, "".LastIndexOf("x", -1, -1, StringComparison.Ordinal), "#32");
4520
4521 Assert.AreEqual (1, "xx".LastIndexOf("", StringComparison.Ordinal), "#33");
4522 Assert.AreEqual (1, "xx".LastIndexOf("", 2, StringComparison.Ordinal), "#34");
4523 Assert.AreEqual (1, "xx".LastIndexOf("", 2, 2, StringComparison.Ordinal), "#35");
4524
4525 Assert.AreEqual (3, "xxxx".LastIndexOf("", StringComparison.Ordinal), "#36");
4526 Assert.AreEqual (2, "xxxx".LastIndexOf("", 2, StringComparison.Ordinal), "#37");
4527 Assert.AreEqual (2, "xxxx".LastIndexOf("", 2, 2, StringComparison.Ordinal), "#38");
4528
4529 Assert.AreEqual (3, "xxxx".LastIndexOf("", 3, StringComparison.Ordinal), "#39");
4530 Assert.AreEqual (3, "xxxx".LastIndexOf("", 3, 3, StringComparison.Ordinal), "#40");
4531 }
4532
4533
4534 [Test]
4535 public void LastIndexOfAnyAndEmptiness () {
4536 Assert.AreEqual (-1, "".LastIndexOfAny(new char[] {'.', 'x'}), "#1");
4537 Assert.AreEqual (-1, "".LastIndexOfAny(new char[] {'.', 'x'}, -1), "#2");
4538 Assert.AreEqual (-1, "".LastIndexOfAny(new char[] {'.', 'x'}, -1, -1), "#3");
4539 }
4540 }
4541
4542 }
Mirror of the official Mono project git repository