1 // StringTest.cs - NUnit Test Cases for the System.String class
4 // Jeffrey Stedfast <fejj@ximian.com>
5 // David Brandt <bucky@keystreams.com>
6 // Kornel Pal <http://www.kornelpal.hu/>
8 // (C) Ximian, Inc. http://www.ximian.com
9 // Copyright (C) 2006 Kornel Pal
10 // Copyright (C) 2006 Novell (http://www.novell.com)
15 using System.Globalization;
16 using System.Reflection;
17 using System.Threading;
19 using NUnit.Framework;
21 namespace MonoTests.System
25 public class StringTest
27 class NullFormatter : IFormatProvider, ICustomFormatter
29 public string Format (string format, object arg, IFormatProvider provider)
34 public object GetFormat (Type formatType)
42 public override string ToString()
48 private CultureInfo orgCulture;
53 // save current culture
54 orgCulture = CultureInfo.CurrentCulture;
58 public void TearDown ()
60 // restore original culture
61 Thread.CurrentThread.CurrentCulture = orgCulture;
65 [Test] // ctor (Char [])
66 public unsafe void Constructor2 ()
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");
73 [Test] // ctor (Char, Int32)
74 public void Constructor4 ()
76 Assert.AreEqual (string.Empty, new String ('A', 0));
77 Assert.AreEqual (new String ('A', 3), "AAA");
80 [Test] // ctor (Char, Int32)
81 public void Constructor4_Count_Negative ()
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");
95 [Test] // ctor (Char [], Int32, Int32)
96 public void Constructor6 ()
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");
104 [Test] // ctor (Char [], Int32, Int32)
105 public void Constructor6_Length_Negative ()
107 char [] arr = new char [3] { 'A', 'B', 'C' };
110 new String (arr, 0, -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");
121 [Test] // ctor (Char [], Int32, Int32)
122 public void Constructor6_Length_Overflow ()
124 char [] arr = new char [3] { 'A', 'B', 'C' };
127 new String (arr, 1, 3);
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");
139 [Test] // ctor (Char [], Int32, Int32)
140 public void Constructor6_StartIndex_Negative ()
142 char [] arr = new char [3] { 'A', 'B', 'C' };
145 new String (arr, -1, 0);
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");
156 [Test] // ctor (Char [], Int32, Int32)
157 public void Constructor6_Value_Null ()
160 new String ((char []) null, 0, 0);
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");
171 public unsafe void CharPtrConstructor ()
173 Assert.AreEqual (String.Empty, new String ((char*) null), "char*");
174 Assert.AreEqual (String.Empty, new String ((char*) null, 0, 0), "char*,int,int");
178 public unsafe void TestSbytePtrConstructorASCII ()
180 Encoding encoding = Encoding.ASCII;
181 String s = "ASCII*\0";
182 byte[] bytes = encoding.GetBytes (s);
184 fixed (byte* bytePtr = bytes)
185 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding));
189 public unsafe void TestSbytePtrConstructorDefault ()
191 Encoding encoding = Encoding.Default;
192 byte [] bytes = new byte [256];
194 for (int i = 0; i < 255; i++)
195 bytes [i] = (byte) (i + 1);
196 bytes [255] = (byte) 0;
198 // Ensure that bytes are valid for Encoding.Default
199 bytes = encoding.GetBytes (encoding.GetChars (bytes));
200 String s = encoding.GetString(bytes);
202 // Ensure null terminated array
203 bytes [bytes.Length - 1] = (byte) 0;
205 fixed (byte* bytePtr = bytes)
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));
214 [Test] // ctor (SByte*)
215 public unsafe void Constructor3_Value_Null ()
217 Assert.AreEqual (String.Empty, new String ((sbyte*) null));
220 [Test] // ctor (SByte*)
221 [Ignore ("invalid test")]
222 public unsafe void Constructor3_Value_Invalid ()
225 new String ((sbyte*) (-1));
227 } catch (ArgumentOutOfRangeException ex) {
228 // Pointer startIndex and length do not refer to a
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");
237 [Test] // ctor (SByte*, Int32, Int32)
238 public unsafe void Constructor7_Length_Negative ()
241 new String ((sbyte*) null, 0, -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");
252 [Test] // ctor (SByte*, Int32, Int32)
253 public unsafe void Constructor7_StartIndex_Negative ()
256 new String ((sbyte*) null, -1, 0);
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");
268 public unsafe void Constructor7_StartIndex_Overflow ()
271 new String ((sbyte*) (-1), 1, 0);
273 } catch (ArgumentOutOfRangeException ex) {
274 // Pointer startIndex and length do not refer to a
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");
283 new String ((sbyte*) (-1), 1, 1);
285 } catch (ArgumentOutOfRangeException ex) {
286 // Pointer startIndex and length do not refer to a
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");
295 [Test] // ctor (SByte*, Int32, Int32)
296 [Ignore ("invalid test")]
297 public unsafe void Constructor7_Value_Invalid ()
300 new String ((sbyte*) (-1), 0, 1);
302 } catch (ArgumentOutOfRangeException ex) {
303 // Pointer startIndex and length do not refer to a
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");
312 [Test] // ctor (SByte*, Int32, Int32)
313 public unsafe void Constructor7_Value_Null ()
316 new String ((sbyte*) null, 0, 0);
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");
326 new String ((sbyte*) null, 0, 1);
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");
336 new String ((sbyte*) null, 1, 0);
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");
346 [Test] // ctor (SByte*, Int32, Int32, Encoding)
347 public unsafe void Constructor8_Length_Negative ()
350 new String ((sbyte*) null, 0, -1, null);
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");
361 new String ((sbyte*) null, 0, -1, Encoding.Default);
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");
372 [Test] // ctor (SByte*, Int32, Int32, Encoding)
373 public unsafe void Constructor8_StartIndex_Negative ()
376 new String ((sbyte*) null, -1, 0, null);
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");
387 new String ((sbyte*) null, -1, 0, Encoding.Default);
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");
399 public unsafe void Constructor8_StartIndex_Overflow ()
402 new String ((sbyte*) (-1), 1, 0, null);
404 } catch (ArgumentOutOfRangeException ex) {
405 // Pointer startIndex and length do not refer to a
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");
414 new String ((sbyte*) (-1), 1, 1, null);
416 } catch (ArgumentOutOfRangeException ex) {
417 // Pointer startIndex and length do not refer to a
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");
426 new String ((sbyte*) (-1), 1, 0, Encoding.Default);
428 } catch (ArgumentOutOfRangeException ex) {
429 // Pointer startIndex and length do not refer to a
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");
438 new String ((sbyte*) (-1), 1, 1, Encoding.Default);
440 } catch (ArgumentOutOfRangeException ex) {
441 // Pointer startIndex and length do not refer to a
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");
450 [Test] // ctor (SByte*, Int32, Int32, Encoding)
451 [Ignore ("invalid test")]
452 public unsafe void Constructor8_Value_Invalid ()
455 new String ((sbyte*) (-1), 0, 1, null);
457 } catch (ArgumentOutOfRangeException ex) {
458 // Pointer startIndex and length do not refer to a
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");
468 [Ignore ("Runtime throws NullReferenceException instead of AccessViolationException")]
469 [ExpectedException (typeof (AccessViolationException))]
470 public unsafe void Constructor8_Value_Invalid2 ()
472 new String ((sbyte*) (-1), 0, 1, Encoding.Default);
475 [Test] // ctor (SByte*, Int32, Int32, Encoding)
476 public unsafe void Constructor8_Value_Null ()
479 new String ((sbyte*) null, 0, 0, null);
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");
489 new String ((sbyte*) null, 0, 1, null);
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");
499 new String ((sbyte*) null, 1, 0, null);
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");
508 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0, Encoding.Default), "#D");
511 new String ((sbyte*) null, 0, 1, Encoding.Default);
513 } catch (ArgumentOutOfRangeException ex) {
514 // Pointer startIndex and length do not refer to a
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");
522 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0, Encoding.Default), "#F");
525 public void Length ()
527 string str = "test string";
529 Assert.AreEqual (11, str.Length, "wrong length");
535 string s1 = "oRiGiNal";
536 Assert.AreEqual (s1, s1.Clone (), "#A1");
537 Assert.AreSame (s1, s1.Clone (), "#A2");
539 string s2 = new DateTime (2000, 6, 3).ToString ();
540 Assert.AreEqual (s2, s2.Clone (), "#B1");
541 Assert.AreSame (s2, s2.Clone (), "#B2");
544 [Test] // bug #316666
545 public void CompareNotWorking ()
547 Assert.AreEqual (String.Compare ("A", "a"), 1, "A03");
548 Assert.AreEqual (String.Compare ("a", "A"), -1, "A04");
552 public void CompareNotWorking2 ()
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++) {
559 Assert.AreEqual (-1, String.Compare(needle, 0, haystack, i, 2, false), "loop substring check #8/" + i);
565 public void Compare ()
567 string lesser = "abc";
568 string medium = "abcd";
569 string greater = "xyz";
572 Assert.AreEqual (0, String.Compare (null, null));
573 Assert.AreEqual (1, String.Compare (lesser, null));
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);
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");
586 // TODO - test with CultureInfo
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");
598 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
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);
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);
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++) {
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);
615 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2, true), "loop substring check #7/" + i);
619 Assert.AreEqual (0, String.Compare (needle, 0, haystack, 0, 0), "Compare with 0 length");
621 // TODO - extended format call with CultureInfo
625 public void CompareOrdinal ()
627 string lesser = "abc";
628 string medium = "abcd";
629 string greater = "xyz";
631 Assert.AreEqual (0, String.CompareOrdinal (null, null));
632 Assert.AreEqual (1, String.CompareOrdinal (lesser, null));
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");
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++) {
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);
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);
655 [ExpectedException (typeof (ArgumentOutOfRangeException))]
656 public void CompareOrdinal_InvalidCount()
658 string.CompareOrdinal ("a", 0, "b", 0, -1);
662 public void CompareOrdinalWithOffset ()
665 string ab2 = "a" + new string ('b', 1);
667 Assert.IsTrue (string.CompareOrdinal (ab1, 0, ab1, 1, 1) < 0, "#1");
668 Assert.IsTrue (string.CompareOrdinal (ab2, 0, ab1, 1, 1) < 0, "#2");
672 public void CompareOrdinalSubstringWithNull ()
674 string lesser = "abc";
675 string greater = "xyz";
677 Assert.AreEqual (0, string.CompareOrdinal (null, 0, null, 0, 0), "substring both null");
678 Assert.AreEqual (-1, string.CompareOrdinal (null, 0, greater, 0, 0), "substring strA null");
679 Assert.AreEqual (-1, string.CompareOrdinal (null, 4, greater, 0, 0), "substring strA null; indexA greater than strA.Length");
680 Assert.AreEqual (-1, string.CompareOrdinal (null, 0, greater, 4, 0), "substring strA null; indexB greater than strB.Length");
681 Assert.AreEqual (-1, string.CompareOrdinal (null, -1, greater, -1, -1), "substring strA null; indexA, indexB, length negative");
682 Assert.AreEqual (1, string.CompareOrdinal (lesser, 0, null, 0, 0), "substring strB null");
683 Assert.AreEqual (1, string.CompareOrdinal (lesser, 4, null, 0, 0), "substring strB null; indexA greater than strA.Length");
684 Assert.AreEqual (1, string.CompareOrdinal (lesser, 0, null, 4, 0), "substring strB null; indexB greater than strB.Length");
685 Assert.AreEqual (1, string.CompareOrdinal (lesser, -1, null, -1, -1), "substring strB null; indexA, indexB, length negative");
689 public void CompareTo ()
691 string lower = "abc";
692 string greater = "xyz";
693 string lesser = "abc";
695 Assert.IsTrue (lower.CompareTo (greater) < 0);
696 Assert.IsTrue (lower.CompareTo (lower) == 0);
697 Assert.IsTrue (greater.CompareTo (lesser) > 0);
702 public override string ToString ()
709 public void Concat ()
711 string string1 = "string1";
712 string string2 = "string2";
713 string concat = "string1string2";
715 Assert.IsTrue (String.Concat (string1, string2) == concat);
717 Assert.AreEqual (string1, String.Concat (string1, null));
718 Assert.AreEqual (string1, String.Concat (null, string1));
719 Assert.AreEqual (string.Empty, String.Concat (null, null));
721 WeirdToString wts = new WeirdToString ();
722 Assert.AreEqual (string1, String.Concat (string1, wts));
723 Assert.AreEqual (string1, String.Concat (wts, string1));
724 Assert.AreEqual (string.Empty, String.Concat (wts, wts));
725 string [] allstr = new string []{ string1, null, string2, concat };
726 object [] allobj = new object []{ string1, null, string2, concat };
727 string astr = String.Concat (allstr);
728 Assert.AreEqual ("string1string2string1string2", astr);
729 string ostr = String.Concat (allobj);
730 Assert.AreEqual (astr, ostr);
736 string s1 = "original";
737 string s2 = String.Copy(s1);
738 Assert.AreEqual (s1, s2, "#1");
739 Assert.IsTrue (!object.ReferenceEquals (s1, s2), "#2");
743 public void Copy_Str_Null ()
746 String.Copy ((string) null);
748 } catch (ArgumentNullException ex) {
749 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
750 Assert.IsNull (ex.InnerException, "#3");
751 Assert.IsNotNull (ex.Message, "#4");
752 Assert.AreEqual ("str", ex.ParamName, "#5");
757 public void CopyTo ()
759 string s1 = "original";
760 char[] c1 = new char[s1.Length];
761 string s2 = new String(c1);
762 Assert.IsTrue (!s1.Equals(s2), "#1");
763 for (int i = 0; i < s1.Length; i++) {
764 s1.CopyTo(i, c1, i, 1);
767 Assert.AreEqual (s1, s2, "#2");
771 public void CopyTo_Count_Negative ()
773 char [] dest = new char [4];
775 "Mono".CopyTo (0, dest, 0, -1);
777 } catch (ArgumentOutOfRangeException ex) {
778 // Count cannot be less than zero
779 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
780 Assert.IsNull (ex.InnerException, "#3");
781 Assert.IsNotNull (ex.Message, "#4");
782 Assert.AreEqual ("count", ex.ParamName, "#5");
787 public void CopyTo_Count_Overflow ()
789 char [] dest = new char [4];
791 "Mono".CopyTo (0, dest, 0, Int32.MaxValue);
793 } catch (ArgumentOutOfRangeException ex) {
794 // Index and count must refer to a location within the
796 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
797 Assert.IsNull (ex.InnerException, "#3");
798 Assert.IsNotNull (ex.Message, "#4");
799 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
804 public void CopyTo_Destination_Null ()
806 string s = "original";
809 s.CopyTo (0, (char []) null, 0, s.Length);
811 } catch (ArgumentNullException ex) {
812 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
813 Assert.IsNull (ex.InnerException, "#3");
814 Assert.IsNotNull (ex.Message, "#4");
815 Assert.AreEqual ("destination", ex.ParamName, "#5");
820 public void CopyTo_DestinationIndex_Negative ()
822 char [] dest = new char [4];
824 "Mono".CopyTo (0, dest, -1, 4);
826 } catch (ArgumentOutOfRangeException ex) {
827 // Index and count must refer to a location within the
829 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
830 Assert.IsNull (ex.InnerException, "#3");
831 Assert.IsNotNull (ex.Message, "#4");
832 Assert.AreEqual ("destinationIndex", ex.ParamName, "#5");
837 public void CopyTo_DestinationIndex_Overflow ()
839 char [] dest = new char [4];
841 "Mono".CopyTo (0, dest, Int32.MaxValue, 4);
843 } catch (ArgumentOutOfRangeException ex) {
844 // Index and count must refer to a location within the
846 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
847 Assert.IsNull (ex.InnerException, "#3");
848 Assert.IsNotNull (ex.Message, "#4");
849 Assert.AreEqual ("destinationIndex", ex.ParamName, "#5");
854 public void CopyTo_SourceIndex_Negative ()
856 char [] dest = new char [4];
858 "Mono".CopyTo (-1, dest, 0, 4);
860 } catch (ArgumentOutOfRangeException ex) {
861 // Index was out of range. Must be non-negative and
862 // less than the size of the collection
863 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
864 Assert.IsNull (ex.InnerException, "#3");
865 Assert.IsNotNull (ex.Message, "#4");
866 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
871 public void CopyTo_SourceIndex_Overflow ()
873 char[] dest = new char [4];
875 "Mono".CopyTo (Int32.MaxValue, dest, 0, 4);
877 } catch (ArgumentOutOfRangeException ex) {
878 // Index and count must refer to a location within the
880 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
881 Assert.IsNull (ex.InnerException, "#3");
882 Assert.IsNotNull (ex.Message, "#4");
883 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
887 [Test] // EndsWith (String)
888 public void EndsWith1 ()
892 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
895 Assert.IsTrue (s.EndsWith ("bC"), "#A1");
896 Assert.IsTrue (!s.EndsWith ("bc"), "#A1");
897 Assert.IsTrue (!s.EndsWith ("dc"), "#A2");
898 Assert.IsTrue (!s.EndsWith ("LAbC"), "#A3");
899 Assert.IsTrue (s.EndsWith (string.Empty), "#A4");
900 Assert.IsTrue (!s.EndsWith ("Ab"), "#A5");
901 Assert.IsTrue (!s.EndsWith ("Abc"), "#A6");
902 Assert.IsTrue (s.EndsWith ("AbC"), "#A7");
906 Assert.IsTrue (s.EndsWith ("ai"), "#B1");
907 Assert.IsTrue (!s.EndsWith ("AI"), "#B2");
908 Assert.IsTrue (!s.EndsWith ("LTai"), "#B3");
909 Assert.IsTrue (s.EndsWith (string.Empty), "#B4");
910 Assert.IsTrue (!s.EndsWith ("Ta"), "#B5");
911 Assert.IsTrue (!s.EndsWith ("tai"), "#B6");
912 Assert.IsTrue (s.EndsWith ("Tai"), "#B7");
914 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
916 Assert.IsTrue (s.EndsWith ("ai"), "#C1");
917 Assert.IsTrue (!s.EndsWith ("AI"), "#C2");
918 Assert.IsTrue (!s.EndsWith ("LTai"), "#C3");
919 Assert.IsTrue (s.EndsWith (string.Empty), "#C4");
920 Assert.IsTrue (!s.EndsWith ("Ta"), "#C5");
921 Assert.IsTrue (!s.EndsWith ("tai"), "#C6");
922 Assert.IsTrue (s.EndsWith ("Tai"), "#C7");
925 [Test] // EndsWith (String)
926 public void EndsWith1_Value_Null ()
929 "ABC".EndsWith ((string) null);
931 } catch (ArgumentNullException ex) {
932 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
933 Assert.IsNull (ex.InnerException, "#3");
934 Assert.IsNotNull (ex.Message, "#4");
935 Assert.AreEqual ("value", ex.ParamName, "#5");
939 [Test] // EndsWith (String, StringComparison)
940 public void EndsWith2_ComparisonType_Invalid ()
943 "ABC".EndsWith ("C", (StringComparison) 80);
945 } catch (ArgumentException ex) {
946 // The string comparison type passed in is currently
948 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
949 Assert.IsNull (ex.InnerException, "#3");
950 Assert.IsNotNull (ex.Message, "#4");
951 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
955 [Test] // EndsWith (String, StringComparison)
956 public void EndsWith2_Value_Null ()
959 "ABC".EndsWith ((string) null, StringComparison.CurrentCulture);
961 } catch (ArgumentNullException ex) {
962 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
963 Assert.IsNull (ex.InnerException, "#3");
964 Assert.IsNotNull (ex.Message, "#4");
965 Assert.AreEqual ("value", ex.ParamName, "#5");
969 [Test] // EndsWith (String, Boolean, CultureInfo)
970 public void EndsWith3 ()
976 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
981 Assert.IsTrue (!s.EndsWith ("bc", ignorecase, culture), "#A1");
982 Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#A2");
983 Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#A3");
984 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#A4");
985 Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#A5");
986 Assert.IsTrue (!s.EndsWith ("Abc", ignorecase, culture), "#A6");
987 Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#A7");
990 Assert.IsTrue (s.EndsWith ("bc", ignorecase, culture), "#B1");
991 Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#B2");
992 Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#B3");
993 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#B4");
994 Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#B5");
995 Assert.IsTrue (s.EndsWith ("Abc", ignorecase, culture), "#B6");
996 Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#B7");
1002 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#C1");
1003 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#C2");
1004 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#C3");
1005 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#C4");
1006 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#C5");
1007 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#C6");
1008 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#C7");
1011 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#D1");
1012 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#D2");
1013 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#D3");
1014 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#D4");
1015 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#D5");
1016 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#D6");
1017 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#D7");
1020 culture = new CultureInfo ("en-US");
1023 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#E1");
1024 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#E2");
1025 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#E3");
1026 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#E4");
1027 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#E5");
1028 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#E6");
1029 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#E7");
1032 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#F1");
1033 Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#F2");
1034 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#F3");
1035 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#F4");
1036 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#F5");
1037 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#F6");
1038 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#F7");
1040 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1044 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#G1");
1045 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#G2");
1046 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#G3");
1047 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#G4");
1048 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#G5");
1049 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#G6");
1050 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#G7");
1053 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#H1");
1054 Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#H2");
1055 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#H3");
1056 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#H4");
1057 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#H5");
1058 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#H6");
1059 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#H7");
1062 [Test] // EndsWith (String, Boolean, CultureInfo)
1063 public void EndsWith3_Value_Null ()
1066 "ABC".EndsWith ((string) null, true, null);
1068 } catch (ArgumentNullException ex) {
1069 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1070 Assert.IsNull (ex.InnerException, "#3");
1071 Assert.IsNotNull (ex.Message, "#4");
1072 Assert.AreEqual ("value", ex.ParamName, "#5");
1077 public void TestEquals ()
1079 string s1 = "original";
1080 string yes = "original";
1083 string s1s1 = s1 + s1;
1085 Assert.IsTrue (!s1.Equals (null), "No match for null");
1086 Assert.IsTrue (s1.Equals (y), "Should match object");
1087 Assert.IsTrue (s1.Equals (yes), "Should match");
1088 Assert.IsTrue (!s1.Equals (no), "Shouldn't match");
1090 Assert.IsTrue (String.Equals (null, null), "Static nulls should match");
1091 Assert.IsTrue (String.Equals (s1, yes), "Should match");
1092 Assert.IsTrue (!String.Equals (s1, no), "Shouldn't match");
1094 Assert.AreEqual (false, s1s1.Equals (y), "Equals (object)");
1098 public void TestFormat ()
1100 Assert.AreEqual (string.Empty, String.Format (string.Empty, 0), "Empty format string.");
1101 Assert.AreEqual ("100", String.Format ("{0}", 100), "Single argument.");
1102 Assert.AreEqual ("X 37X", String.Format ("X{0,5}X", 37), "Single argument, right justified.");
1103 Assert.AreEqual ("X37 X", String.Format ("X{0,-5}X", 37), "Single argument, left justified.");
1104 Assert.AreEqual (" 7d", String.Format ("{0, 4:x}", 125), "Whitespace in specifier");
1105 Assert.AreEqual ("The 3 wise men.", String.Format ("The {0} wise {1}.", 3, "men"), "Two arguments.");
1106 Assert.AreEqual ("do re me fa so.", String.Format ("{0} re {1} fa {2}.", "do", "me", "so"), "Three arguments.");
1107 Assert.AreEqual ("###00c0ffee#", String.Format ("###{0:x8}#", 0xc0ffee), "Formatted argument.");
1108 Assert.AreEqual ("# 033#", String.Format ("#{0,5:x3}#", 0x33), "Formatted argument, right justified.");
1109 Assert.AreEqual ("#033 #", String.Format ("#{0,-5:x3}#", 0x33), "Formatted argument, left justified.");
1110 Assert.AreEqual ("typedef struct _MonoObject { ... } MonoObject;", String.Format ("typedef struct _{0} {{ ... }} MonoObject;", "MonoObject"), "Escaped bracket");
1111 Assert.AreEqual ("Could not find file \"a/b\"", String.Format ("Could not find file \"{0}\"", "a/b"), "With Slash");
1112 Assert.AreEqual ("Could not find file \"a\\b\"", String.Format ("Could not find file \"{0}\"", "a\\b"), "With BackSlash");
1113 Assert.AreEqual ("{d} ", string.Format ("{{{0:d}} }", 100));
1116 [Test] // Format (String, Object)
1117 public void Format1_Format_Null ()
1120 String.Format (null, 1);
1122 } catch (ArgumentNullException ex) {
1123 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1124 Assert.IsNull (ex.InnerException, "#3");
1125 Assert.IsNotNull (ex.Message, "#4");
1126 Assert.AreEqual ("format", ex.ParamName, "#5");
1130 [Test] // Format (String, Object [])
1131 public void Format2_Format_Null ()
1134 String.Format (null, new object [] { 2 });
1136 } catch (ArgumentNullException ex) {
1137 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1138 Assert.IsNull (ex.InnerException, "#3");
1139 Assert.IsNotNull (ex.Message, "#4");
1140 Assert.AreEqual ("format", ex.ParamName, "#5");
1144 [Test] // Format (String, Object [])
1145 public void Format2_Args_Null ()
1148 String.Format ("text", (object []) null);
1150 } catch (ArgumentNullException ex) {
1151 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1152 Assert.IsNull (ex.InnerException, "#3");
1153 Assert.IsNotNull (ex.Message, "#4");
1154 Assert.AreEqual ("args", ex.ParamName, "#5");
1158 [Test] // Format (IFormatProvider, String, Object [])
1159 public void Format3_Format_Null ()
1162 String.Format (CultureInfo.InvariantCulture, null,
1163 new object [] { 3 });
1165 } catch (ArgumentNullException ex) {
1166 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1167 Assert.IsNull (ex.InnerException, "#3");
1168 Assert.IsNotNull (ex.Message, "#4");
1169 Assert.AreEqual ("format", ex.ParamName, "#5");
1173 [Test] // Format (IFormatProvider, String, Object [])
1174 public void Format3_Args_Null ()
1177 String.Format (CultureInfo.InvariantCulture, "text",
1180 } catch (ArgumentNullException ex) {
1181 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1182 Assert.IsNull (ex.InnerException, "#3");
1183 Assert.IsNotNull (ex.Message, "#4");
1184 Assert.AreEqual ("args", ex.ParamName, "#5");
1188 [Test] // Format (String, Object, Object)
1189 public void Format4_Format_Null ()
1192 String.Format (null, 4, 5);
1194 } catch (ArgumentNullException ex) {
1195 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1196 Assert.IsNull (ex.InnerException, "#3");
1197 Assert.IsNotNull (ex.Message, "#4");
1198 Assert.AreEqual ("format", ex.ParamName, "#5");
1202 [Test] // Format (String, Object, Object, Object)
1203 public void Format5_Format_Null ()
1206 String.Format (null, 4, 5, 6);
1208 } catch (ArgumentNullException ex) {
1209 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1210 Assert.IsNull (ex.InnerException, "#3");
1211 Assert.IsNotNull (ex.Message, "#4");
1212 Assert.AreEqual ("format", ex.ParamName, "#5");
1217 public void Format ()
1219 var s = String.Format (new NullFormatter (), "{0:}", "test");
1220 Assert.AreEqual ("test", s);
1224 public void Format_Arg_ToNullStringer ()
1226 var s = String.Format ("{0}", new ToNullStringer ());
1227 Assert.AreEqual ("", s);
1231 public void TestGetEnumerator ()
1233 string s1 = "original";
1234 char[] c1 = new char[s1.Length];
1235 string s2 = new String(c1);
1236 Assert.IsTrue (!s1.Equals(s2), "pre-enumerated string should not match");
1237 CharEnumerator en = s1.GetEnumerator();
1238 Assert.IsNotNull (en, "null enumerator");
1240 for (int i = 0; i < s1.Length; i++) {
1244 s2 = new String(c1);
1245 Assert.AreEqual (s1, s2, "enumerated string should match");
1249 public void TestGetHashCode ()
1251 string s1 = "original";
1252 // TODO - weak test, currently. Just verifies determinicity.
1253 Assert.AreEqual (s1.GetHashCode(), s1.GetHashCode(), "same string, same hash code");
1257 public void TestGetType ()
1259 string s1 = "original";
1260 Assert.AreEqual ("System.String", s1.GetType().ToString(), "String type");
1264 public void TestGetTypeCode ()
1266 string s1 = "original";
1267 Assert.IsTrue (s1.GetTypeCode().Equals(TypeCode.String));
1271 public void IndexOf ()
1273 string s1 = "original";
1276 s1.IndexOf ('q', s1.Length + 1);
1277 Assert.Fail ("#A1");
1278 } catch (ArgumentOutOfRangeException ex) {
1279 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1280 Assert.IsNull (ex.InnerException, "#A3");
1281 Assert.IsNotNull (ex.Message, "#A4");
1282 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
1286 s1.IndexOf ('q', s1.Length + 1, 1);
1287 Assert.Fail ("#B1");
1288 } catch (ArgumentOutOfRangeException ex) {
1289 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1290 Assert.IsNull (ex.InnerException, "#B3");
1291 Assert.IsNotNull (ex.Message, "#B4");
1292 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
1296 s1.IndexOf ("huh", s1.Length + 1);
1297 Assert.Fail ("#C1");
1298 } catch (ArgumentOutOfRangeException ex) {
1299 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1300 Assert.IsNull (ex.InnerException, "#C3");
1301 Assert.IsNotNull (ex.Message, "#C4");
1302 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
1305 Assert.AreEqual (1, s1.IndexOf('r'), "basic char index");
1306 Assert.AreEqual (2, s1.IndexOf('i'), "basic char index 2");
1307 Assert.AreEqual (-1, s1.IndexOf('q'), "basic char index - no");
1309 Assert.AreEqual (1, s1.IndexOf("rig"), "basic string index");
1310 Assert.AreEqual (2, s1.IndexOf("i"), "basic string index 2");
1311 Assert.AreEqual (0, string.Empty.IndexOf(string.Empty), "basic string index 3");
1312 Assert.AreEqual (0, "ABC".IndexOf(string.Empty), "basic string index 4");
1313 Assert.AreEqual (-1, s1.IndexOf("rag"), "basic string index - no");
1315 Assert.AreEqual (1, s1.IndexOf('r', 1), "stepped char index");
1316 Assert.AreEqual (2, s1.IndexOf('i', 1), "stepped char index 2");
1317 Assert.AreEqual (4, s1.IndexOf('i', 3), "stepped char index 3");
1318 Assert.AreEqual (-1, s1.IndexOf('i', 5), "stepped char index 4");
1319 Assert.AreEqual (-1, s1.IndexOf('l', s1.Length), "stepped char index 5");
1321 Assert.AreEqual (1, s1.IndexOf('r', 1, 1), "stepped limited char index");
1322 Assert.AreEqual (-1, s1.IndexOf('r', 0, 1), "stepped limited char index");
1323 Assert.AreEqual (2, s1.IndexOf('i', 1, 3), "stepped limited char index");
1324 Assert.AreEqual (4, s1.IndexOf('i', 3, 3), "stepped limited char index");
1325 Assert.AreEqual (-1, s1.IndexOf('i', 5, 3), "stepped limited char index");
1327 s1 = "original original";
1328 Assert.AreEqual (0, s1.IndexOf("original", 0), "stepped string index 1");
1329 Assert.AreEqual (9, s1.IndexOf("original", 1), "stepped string index 2");
1330 Assert.AreEqual (-1, s1.IndexOf("original", 10), "stepped string index 3");
1331 Assert.AreEqual (3, s1.IndexOf(string.Empty, 3), "stepped string index 4");
1332 Assert.AreEqual (1, s1.IndexOf("rig", 0, 5), "stepped limited string index 1");
1333 Assert.AreEqual (-1, s1.IndexOf("rig", 0, 3), "stepped limited string index 2");
1334 Assert.AreEqual (10, s1.IndexOf("rig", 2, 15), "stepped limited string index 3");
1335 Assert.AreEqual (-1, s1.IndexOf("rig", 2, 3), "stepped limited string index 4");
1336 Assert.AreEqual (2, s1.IndexOf(string.Empty, 2, 3), "stepped limited string index 5");
1338 string s2 = "QBitArray::bitarr_data";
1339 Assert.AreEqual (9, s2.IndexOf ("::"), "bug #62160");
1342 [Test] // IndexOf (String)
1343 public void IndexOf2_Value_Null ()
1346 "Mono".IndexOf ((string) null);
1348 } catch (ArgumentNullException ex) {
1349 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1350 Assert.IsNull (ex.InnerException, "#3");
1351 Assert.IsNotNull (ex.Message, "#4");
1352 Assert.AreEqual ("value", ex.ParamName, "#5");
1356 [Test] // IndexOf (Char, Int32)
1357 public void IndexOf3 ()
1359 string s = "testing123456";
1361 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1363 Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#A1");
1364 Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#A2");
1365 Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#A3");
1366 Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#A4");
1367 Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#A5");
1368 Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#A6");
1369 Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#A7");
1370 Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#A8");
1372 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1374 Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#B1");
1375 Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#B2");
1376 Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#B3");
1377 Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#B4");
1378 Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#B5");
1379 Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#B6");
1380 Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#B7");
1381 Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#B8");
1384 [Test] // IndexOf (String, Int32)
1385 public void IndexOf4 ()
1387 string s = "testing123456";
1389 Assert.AreEqual (-1, s.IndexOf ("IN", 3), "#1");
1390 Assert.AreEqual (4, s.IndexOf ("in", 3), "#2");
1391 Assert.AreEqual (-1, s.IndexOf ("in", 5), "#3");
1392 Assert.AreEqual (7, s.IndexOf ("1", 5), "#4");
1393 Assert.AreEqual (12, s.IndexOf ("6", 12), "#5");
1394 Assert.AreEqual (0, s.IndexOf ("testing123456", 0), "#6");
1395 Assert.AreEqual (-1, s.IndexOf ("testing123456", 1), "#7");
1396 Assert.AreEqual (5, s.IndexOf (string.Empty, 5), "#8");
1397 Assert.AreEqual (0, s.IndexOf (string.Empty, 0), "#9");
1400 [Test] // IndexOf (String, Int32)
1401 public void IndexOf4_Value_Null ()
1404 "Mono".IndexOf ((string) null, 1);
1406 } catch (ArgumentNullException ex) {
1407 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1408 Assert.IsNull (ex.InnerException, "#3");
1409 Assert.IsNotNull (ex.Message, "#4");
1410 Assert.AreEqual ("value", ex.ParamName, "#5");
1414 [Test] // IndexOf (String, StringComparison)
1415 public void IndexOf5 ()
1417 string s = "testing123456";
1418 StringComparison comparison_type;
1420 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1422 comparison_type = StringComparison.CurrentCulture;
1423 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#A1");
1424 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#A2");
1425 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#A3");
1426 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#A4");
1427 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#A5");
1428 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#A6");
1429 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#A7");
1430 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#A8");
1431 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#A9");
1433 comparison_type = StringComparison.CurrentCultureIgnoreCase;
1434 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#B1");
1435 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#B2");
1436 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#B3");
1437 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#B4");
1438 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#B5");
1439 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#B6");
1440 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#B7");
1441 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#B8");
1442 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#B9");
1444 comparison_type = StringComparison.InvariantCulture;
1445 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#C1");
1446 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#C2");
1447 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#C3");
1448 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#C4");
1449 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#C5");
1450 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#C6");
1451 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#C7");
1452 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#C8");
1453 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#C9");
1455 comparison_type = StringComparison.InvariantCultureIgnoreCase;
1456 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#D1");
1457 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#D2");
1458 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#D3");
1459 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#D4");
1460 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#D5");
1461 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#D6");
1462 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#D7");
1463 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#D8");
1464 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#D9");
1466 comparison_type = StringComparison.Ordinal;
1467 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#E1");
1468 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#E2");
1469 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#E3");
1470 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#E4");
1471 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#E5");
1472 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#E6");
1473 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#E7");
1474 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#E8");
1475 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#E9");
1477 comparison_type = StringComparison.OrdinalIgnoreCase;
1478 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#F1");
1479 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#F2");
1480 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#F3");
1481 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#F4");
1482 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#F5");
1483 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#F6");
1484 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#F7");
1485 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#F8");
1486 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#F9");
1488 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1490 comparison_type = StringComparison.CurrentCulture;
1491 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#G1");
1492 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#G2");
1493 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#G3");
1494 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#G4");
1495 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#G5");
1496 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#G6");
1497 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#G7");
1498 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#G8");
1499 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#G9");
1501 comparison_type = StringComparison.CurrentCultureIgnoreCase;
1502 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#H1");
1503 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#H2");
1504 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#H3");
1505 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#H4");
1506 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#H5");
1507 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#H6");
1508 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#H7");
1509 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#H8");
1510 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#H9");
1512 comparison_type = StringComparison.InvariantCulture;
1513 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#I1");
1514 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#I2");
1515 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#I3");
1516 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#I4");
1517 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#I5");
1518 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#I6");
1519 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#I7");
1520 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#I8");
1521 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#I9");
1523 comparison_type = StringComparison.InvariantCultureIgnoreCase;
1524 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#J1");
1525 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#J2");
1526 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#J3");
1527 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#J4");
1528 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#J5");
1529 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#J6");
1530 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#J7");
1531 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#J8");
1532 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#J9");
1534 comparison_type = StringComparison.Ordinal;
1535 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#K1");
1536 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#K2");
1537 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#K3");
1538 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#K4");
1539 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#K5");
1540 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#K6");
1541 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#K7");
1542 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#K8");
1543 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#K9");
1545 comparison_type = StringComparison.OrdinalIgnoreCase;
1546 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#L1");
1547 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#L2");
1548 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#L3");
1549 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#L4");
1550 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#L5");
1551 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#L6");
1552 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#L7");
1553 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#L8");
1554 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#L9");
1556 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, comparison_type), "#M");
1559 [Test] // IndexOf (String, StringComparison)
1560 public void IndexOf5_ComparisonType_Invalid ()
1563 "Mono".IndexOf (string.Empty, (StringComparison) Int32.MinValue);
1565 } catch (ArgumentException ex) {
1566 // The string comparison type passed in is currently
1568 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1569 Assert.IsNull (ex.InnerException, "#3");
1570 Assert.IsNotNull (ex.Message, "#4");
1571 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
1575 [Test] // IndexOf (String, StringComparison)
1576 public void IndexOf5_Value_Null ()
1579 "Mono".IndexOf ((string) null, StringComparison.Ordinal);
1581 } catch (ArgumentNullException ex) {
1582 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1583 Assert.IsNull (ex.InnerException, "#3");
1584 Assert.IsNotNull (ex.Message, "#4");
1585 Assert.AreEqual ("value", ex.ParamName, "#5");
1590 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1591 public void IndexOfStringComparisonOrdinalRangeException1 ()
1593 "Mono".IndexOf ("no", 5, StringComparison.Ordinal);
1597 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1598 public void IndexOfStringComparisonOrdinalRangeException2 ()
1600 "Mono".IndexOf ("no", 1, 5, StringComparison.Ordinal);
1604 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1605 public void IndexOfStringComparisonOrdinalIgnoreCaseRangeException1 ()
1607 "Mono".IndexOf ("no", 5, StringComparison.OrdinalIgnoreCase);
1611 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1612 public void IndexOfStringComparisonOrdinalIgnoreCaseRangeException2 ()
1614 "Mono".IndexOf ("no", 1, 5, StringComparison.OrdinalIgnoreCase);
1618 public void IndexOfStringComparisonCurrentCulture_Empty ()
1620 Assert.AreEqual (1, "Mono".IndexOf ("", 1, StringComparison.CurrentCultureIgnoreCase));
1624 public void IndexOfStringComparison ()
1626 string text = "testing123456";
1627 string text2 = "123";
1628 string text3 = "NG";
1630 Assert.AreEqual (7, text.IndexOf (text2, StringComparison.Ordinal), "#1-1");
1631 Assert.AreEqual (5, text.IndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1");
1633 Assert.AreEqual (7, text.IndexOf (text2, 0, StringComparison.Ordinal), "#1-2");
1634 Assert.AreEqual (5, text.IndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-2");
1636 Assert.AreEqual (7, text.IndexOf (text2, 1, StringComparison.Ordinal), "#1-3");
1637 Assert.AreEqual (5, text.IndexOf (text3, 1, StringComparison.OrdinalIgnoreCase), "#2-3");
1639 Assert.AreEqual (7, text.IndexOf (text2, 6, StringComparison.Ordinal), "#1-4");
1640 Assert.AreEqual (-1, text.IndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4");
1642 Assert.AreEqual (7, text.IndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5");
1643 Assert.AreEqual (-1, text.IndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5");
1645 Assert.AreEqual (-1, text.IndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6");
1646 Assert.AreEqual (-1, text.IndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6");
1648 Assert.AreEqual (-1, text.IndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7");
1649 Assert.AreEqual (-1, text.IndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7");
1651 Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.Ordinal), "#3-1");
1652 Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2");
1654 Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.Ordinal), "#4-1");
1655 Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2");
1657 Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.Ordinal), "#4-1");
1658 Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.OrdinalIgnoreCase), "#4-2");
1660 Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.Ordinal), "#5-1");
1661 Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.OrdinalIgnoreCase), "#5-2");
1665 public void IndexOfStringComparisonOrdinal ()
1667 string text = "testing123456";
1668 Assert.AreEqual (10, text.IndexOf ("456", StringComparison.Ordinal), "#1");
1669 Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.Ordinal), "#2");
1670 Assert.AreEqual (0, text.IndexOf ("te", StringComparison.Ordinal), "#3");
1671 Assert.AreEqual (2, text.IndexOf ("s", StringComparison.Ordinal), "#4");
1672 Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.Ordinal), "#5");
1673 Assert.AreEqual (-1, text.IndexOf ("S", StringComparison.Ordinal), "#6");
1677 public void IndexOfStringComparisonOrdinalIgnoreCase ()
1679 string text = "testing123456";
1680 Assert.AreEqual (10, text.IndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1");
1681 Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2");
1682 Assert.AreEqual (0, text.IndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3");
1683 Assert.AreEqual (2, text.IndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4");
1684 Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5");
1685 Assert.AreEqual (2, text.IndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6");
1689 public void IndexOfOrdinalCountSmallerThanValueString ()
1691 Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.Ordinal), "#1");
1692 Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#2");
1693 Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.Ordinal), "#3");
1694 Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#4");
1697 [Test] // IndexOf (Char, Int32, Int32)
1698 public void IndexOf6_Count_Negative ()
1701 "Mono".IndexOf ('o', 1, -1);
1703 } catch (ArgumentOutOfRangeException ex) {
1704 // Count must be positive and count must refer to a
1705 // location within the string/array/collection
1706 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1707 Assert.IsNull (ex.InnerException, "#3");
1708 Assert.IsNotNull (ex.Message, "#4");
1709 Assert.AreEqual ("count", ex.ParamName, "#5");
1713 [Test] // IndexOf (Char, Int32, Int32)
1714 public void IndexOf6_Count_Overflow ()
1717 "Mono".IndexOf ('o', 1, Int32.MaxValue);
1719 } catch (ArgumentOutOfRangeException ex) {
1720 // Count must be positive and count must refer to a
1721 // location within the string/array/collection
1722 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1723 Assert.IsNull (ex.InnerException, "#3");
1724 Assert.IsNotNull (ex.Message, "#4");
1725 Assert.AreEqual ("count", ex.ParamName, "#5");
1729 [Test] // IndexOf (Char, Int32, Int32)
1730 public void IndexOf6_StartIndex_Negative ()
1733 "Mono".IndexOf ('o', -1, 1);
1735 } catch (ArgumentOutOfRangeException ex) {
1736 // Index was out of range. Must be non-negative and
1737 // less than the size of the collection
1738 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1739 Assert.IsNull (ex.InnerException, "#3");
1740 Assert.IsNotNull (ex.Message, "#4");
1741 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1745 [Test] // IndexOf (Char, Int32, Int32)
1746 public void IndexOf6_StartIndex_Overflow ()
1748 string s = "testing123456";
1751 s.IndexOf ('o', s.Length + 1, 1);
1753 } catch (ArgumentOutOfRangeException ex) {
1754 // Index was out of range. Must be non-negative and
1755 // less than the size of the collection
1756 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1757 Assert.IsNull (ex.InnerException, "#3");
1758 Assert.IsNotNull (ex.Message, "#4");
1759 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1763 [Test] // IndexOf (String, Int32, Int32)
1764 public void IndexOf7 ()
1766 string s = "testing123456test";
1768 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1770 Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#A1");
1771 Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#A2");
1772 Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#A3");
1773 Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#A4");
1774 Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#A5");
1775 Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#A6");
1777 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#B1");
1778 Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#B2");
1779 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#B3");
1780 Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#B4");
1781 Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#B5");
1782 Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#B6");
1784 Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#C1");
1785 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#C2");
1786 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#C3");
1787 Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#C4");
1788 Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#C5");
1789 Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#C6");
1791 Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#D1");
1792 Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#D2");
1793 Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#D3");
1794 Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#D4");
1795 Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#D5");
1796 Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#D6");
1798 Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#E1");
1799 Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#E2");
1800 Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#E3");
1801 Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#E4");
1802 Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#E5");
1803 Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#E6");
1804 Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#E7");
1805 Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#E8");
1806 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#E9");
1807 Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#E10");
1809 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1811 Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#F1");
1812 Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#F2");
1813 Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#F3");
1814 Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#F4");
1815 Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#F5");
1816 Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#F6");
1818 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#G1");
1819 Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#G2");
1820 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#G3");
1821 Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#G4");
1822 Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#G5");
1823 Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#G6");
1825 Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#H1");
1826 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#H2");
1827 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#H3");
1828 Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#H4");
1829 Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#H5");
1830 Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#H6");
1832 Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#I1");
1833 Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#I2");
1834 Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#I3");
1835 Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#I4");
1836 Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#I5");
1837 Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#I6");
1839 Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#J1");
1840 Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#J2");
1841 Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#J3");
1842 Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#J4");
1843 Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#J5");
1844 Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#J6");
1845 Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#J7");
1846 Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#J8");
1847 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#J9");
1848 Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#J10");
1852 public void IndexOf7_Empty ()
1854 Assert.AreEqual (1, "FOO".IndexOf ("", 1, 2, StringComparison.Ordinal));
1855 Assert.AreEqual (1, "FOO".IndexOf ("", 1, 2, StringComparison.OrdinalIgnoreCase));
1858 [Test] // IndexOf (String, Int32, Int32)
1859 public void IndexOf7_Count_Negative ()
1862 "Mono".IndexOf ("no", 1, -1);
1864 } catch (ArgumentOutOfRangeException ex) {
1865 // Count must be positive and count must refer to a
1866 // location within the string/array/collection
1867 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1868 Assert.IsNull (ex.InnerException, "#3");
1869 Assert.IsNotNull (ex.Message, "#4");
1870 Assert.AreEqual ("count", ex.ParamName, "#5");
1874 [Test] // IndexOf (String, Int32, Int32)
1875 public void IndexOf7_Count_Overflow ()
1877 string s = "testing123456";
1880 s.IndexOf ("no", 1, s.Length);
1881 Assert.Fail ("#A1");
1882 } catch (ArgumentOutOfRangeException ex) {
1883 // Count must be positive and count must refer to a
1884 // location within the string/array/collection
1885 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1886 Assert.IsNull (ex.InnerException, "#A3");
1887 Assert.IsNotNull (ex.Message, "#A4");
1888 Assert.AreEqual ("count", ex.ParamName, "#A5");
1892 s.IndexOf ("no", 1, s.Length + 1);
1893 Assert.Fail ("#B1");
1894 } catch (ArgumentOutOfRangeException ex) {
1895 // Count must be positive and count must refer to a
1896 // location within the string/array/collection
1897 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1898 Assert.IsNull (ex.InnerException, "#B3");
1899 Assert.IsNotNull (ex.Message, "#B4");
1900 Assert.AreEqual ("count", ex.ParamName, "#B5");
1904 s.IndexOf ("no", 1, int.MaxValue);
1905 Assert.Fail ("#C1");
1906 } catch (ArgumentOutOfRangeException ex) {
1907 // Count must be positive and count must refer to a
1908 // location within the string/array/collection
1909 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1910 Assert.IsNull (ex.InnerException, "#C3");
1911 Assert.IsNotNull (ex.Message, "#C4");
1912 Assert.AreEqual ("count", ex.ParamName, "#C5");
1916 [Test] // IndexOf (String, Int32, Int32)
1917 public void IndexOf7_StartIndex_Negative ()
1920 "Mono".IndexOf ("no", -1, 1);
1922 } catch (ArgumentOutOfRangeException ex) {
1923 // Index was out of range. Must be non-negative and
1924 // less than the size of the collection
1925 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1926 Assert.IsNull (ex.InnerException, "#3");
1927 Assert.IsNotNull (ex.Message, "#4");
1928 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1932 [Test] // IndexOf (String, Int32, Int32)
1933 public void IndexOf7_StartIndex_Overflow ()
1935 string s = "testing123456";
1938 s.IndexOf ("no", s.Length + 1, 1);
1939 Assert.Fail ("#A1");
1940 } catch (ArgumentOutOfRangeException ex) {
1941 // Index was out of range. Must be non-negative and
1942 // less than the size of the collection
1943 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1944 Assert.IsNull (ex.InnerException, "#A3");
1945 Assert.IsNotNull (ex.Message, "#A4");
1946 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
1950 s.IndexOf ("no", int.MaxValue, 1);
1951 Assert.Fail ("#B1");
1952 } catch (ArgumentOutOfRangeException ex) {
1953 // Index was out of range. Must be non-negative and
1954 // less than the size of the collection
1955 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1956 Assert.IsNull (ex.InnerException, "#B3");
1957 Assert.IsNotNull (ex.Message, "#B4");
1958 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
1962 [Test] // IndexOf (String, Int32, Int32)
1963 public void IndexOf7_Value_Null ()
1966 "Mono".IndexOf ((string) null, 0, 1);
1968 } catch (ArgumentNullException ex) {
1969 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1970 Assert.IsNull (ex.InnerException, "#3");
1971 Assert.IsNotNull (ex.Message, "#4");
1972 Assert.AreEqual ("value", ex.ParamName, "#5");
1976 [Test] // IndexOf (String, Int32, StringComparison)
1977 public void IndexOf8_ComparisonType_Invalid ()
1980 "Mono".IndexOf (string.Empty, 1, (StringComparison) Int32.MinValue);
1982 } catch (ArgumentException ex) {
1983 // The string comparison type passed in is currently
1985 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1986 Assert.IsNull (ex.InnerException, "#3");
1987 Assert.IsNotNull (ex.Message, "#4");
1988 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
1992 [Test] // IndexOf (String, Int32, StringComparison)
1993 public void IndexOf8_StartIndex_Negative ()
1996 "Mono".IndexOf ("o", -1, StringComparison.Ordinal);
1998 } catch (ArgumentOutOfRangeException ex) {
1999 // Index was out of range. Must be non-negative and
2000 // less than the size of the collection
2001 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2002 Assert.IsNull (ex.InnerException, "#3");
2003 Assert.IsNotNull (ex.Message, "#4");
2004 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2008 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2009 public void IndexOf9_ComparisonType_Invalid ()
2012 "Mono".IndexOf (string.Empty, 0, 1, (StringComparison) Int32.MinValue);
2014 } catch (ArgumentException ex) {
2015 // The string comparison type passed in is currently
2017 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2018 Assert.IsNull (ex.InnerException, "#3");
2019 Assert.IsNotNull (ex.Message, "#4");
2020 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
2024 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2025 public void IndexOf9_Count_Negative ()
2028 "Mono".IndexOf ("o", 1, -1, StringComparison.Ordinal);
2031 } catch (ArgumentOutOfRangeException ex) {
2032 // Count must be positive and count must refer to a
2033 // location within the string/array/collection
2034 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2035 Assert.IsNull (ex.InnerException, "#3");
2036 Assert.IsNotNull (ex.Message, "#4");
2037 Assert.AreEqual ("count", ex.ParamName, "#5");
2041 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2042 public void IndexOf9_StartIndex_Negative ()
2045 "Mono".IndexOf ("o", -1, 0, StringComparison.Ordinal);
2047 } catch (ArgumentOutOfRangeException ex) {
2048 // Index was out of range. Must be non-negative and
2049 // less than the size of the collection
2050 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2051 Assert.IsNull (ex.InnerException, "#3");
2052 Assert.IsNotNull (ex.Message, "#4");
2053 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2058 public void IndexOfAny1 ()
2060 string s = "abcdefghijklmd";
2063 c = new char [] {'a', 'e', 'i', 'o', 'u'};
2064 Assert.AreEqual (0, s.IndexOfAny (c), "#1");
2065 c = new char [] { 'd', 'z' };
2066 Assert.AreEqual (3, s.IndexOfAny (c), "#1");
2067 c = new char [] { 'q', 'm', 'z' };
2068 Assert.AreEqual (12, s.IndexOfAny (c), "#2");
2070 Assert.AreEqual (-1, s.IndexOfAny (c), "#3");
2074 [Test] // IndexOfAny (Char [])
2075 public void IndexOfAny1_AnyOf_Null ()
2078 "mono".IndexOfAny ((char []) null);
2080 } catch (ArgumentNullException ex) {
2081 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2082 Assert.IsNull (ex.InnerException, "#3");
2083 Assert.IsNotNull (ex.Message, "#4");
2084 Assert.IsNull (ex.ParamName, "#5");
2088 [Test] // IndexOfAny (Char [], Int32)
2089 public void IndexOfAny2 ()
2091 string s = "abcdefghijklmd";
2094 c = new char [] { 'a', 'e', 'i', 'o', 'u' };
2095 Assert.AreEqual (0, s.IndexOfAny (c, 0), "#A1");
2096 Assert.AreEqual (4, s.IndexOfAny (c, 1), "#A1");
2097 Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#A2");
2098 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#A3");
2100 c = new char [] { 'd', 'z' };
2101 Assert.AreEqual (3, s.IndexOfAny (c, 0), "#B1");
2102 Assert.AreEqual (3, s.IndexOfAny (c, 3), "#B2");
2103 Assert.AreEqual (13, s.IndexOfAny (c, 4), "#B3");
2104 Assert.AreEqual (13, s.IndexOfAny (c, 9), "#B4");
2105 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#B5");
2106 Assert.AreEqual (13, s.IndexOfAny (c, s.Length - 1), "#B6");
2108 c = new char [] { 'q', 'm', 'z' };
2109 Assert.AreEqual (12, s.IndexOfAny (c, 0), "#C1");
2110 Assert.AreEqual (12, s.IndexOfAny (c, 4), "#C2");
2111 Assert.AreEqual (12, s.IndexOfAny (c, 12), "#C3");
2112 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#C4");
2115 Assert.AreEqual (-1, s.IndexOfAny (c, 0), "#D1");
2116 Assert.AreEqual (-1, s.IndexOfAny (c, 4), "#D2");
2117 Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#D3");
2118 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#D4");
2121 [Test] // IndexOfAny (Char [], Int32)
2122 public void IndexOfAny2_AnyOf_Null ()
2125 "mono".IndexOfAny ((char []) null, 0);
2127 } catch (ArgumentNullException ex) {
2128 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2129 Assert.IsNull (ex.InnerException, "#3");
2130 Assert.IsNotNull (ex.Message, "#4");
2131 Assert.IsNull (ex.ParamName, "#5");
2135 [Test] // IndexOfAny (Char [], Int32)
2136 public void IndexOfAny2_StartIndex_Negative ()
2138 string s = "abcdefghijklm";
2141 s.IndexOfAny (new char [1] { 'd' }, -1, 1);
2143 } catch (ArgumentOutOfRangeException ex) {
2144 // Specified argument was out of the range of valid
2146 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2147 Assert.IsNull (ex.InnerException, "#3");
2148 Assert.IsNotNull (ex.Message, "#4");
2149 Assert.IsNull (ex.ParamName, "#5");
2153 [Test] // IndexOfAny (Char [], Int32, Int32)
2154 public void IndexOfAny2_StartIndex_Overflow ()
2156 string s = "abcdefghijklm";
2159 s.IndexOfAny (new char [1] { 'd' }, s.Length + 1);
2161 } catch (ArgumentOutOfRangeException ex) {
2162 // Specified argument was out of the range of valid
2164 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2165 Assert.IsNull (ex.InnerException, "#3");
2166 Assert.IsNotNull (ex.Message, "#4");
2167 Assert.IsNull (ex.ParamName, "#5");
2171 [Test] // IndexOfAny (Char [], Int32, Int32)
2172 public void IndexOfAny3 ()
2174 string s = "abcdefghijklmd";
2177 c = new char [] { 'a', 'e', 'i', 'o', 'u' };
2178 Assert.AreEqual (0, s.IndexOfAny (c, 0, 2), "#A1");
2179 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#A2");
2180 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#A3");
2181 Assert.AreEqual (4, s.IndexOfAny (c, 1, 4), "#A3");
2182 Assert.AreEqual (4, s.IndexOfAny (c, 1, s.Length - 1), "#A4");
2184 c = new char [] { 'd', 'z' };
2185 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 2), "#B1");
2186 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#B2");
2187 Assert.AreEqual (3, s.IndexOfAny (c, 1, 3), "#B3");
2188 Assert.AreEqual (3, s.IndexOfAny (c, 0, s.Length), "#B4");
2189 Assert.AreEqual (3, s.IndexOfAny (c, 1, s.Length - 1), "#B5");
2190 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length, 0), "#B6");
2192 c = new char [] { 'q', 'm', 'z' };
2193 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 10), "#C1");
2194 Assert.AreEqual (12, s.IndexOfAny (c, 10, 4), "#C2");
2195 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#C3");
2196 Assert.AreEqual (12, s.IndexOfAny (c, 0, s.Length), "#C4");
2197 Assert.AreEqual (12, s.IndexOfAny (c, 1, s.Length - 1), "#C5");
2200 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 3), "#D1");
2201 Assert.AreEqual (-1, s.IndexOfAny (c, 4, 9), "#D2");
2202 Assert.AreEqual (-1, s.IndexOfAny (c, 9, 5), "#D3");
2203 Assert.AreEqual (-1, s.IndexOfAny (c, 13, 1), "#D4");
2206 [Test] // IndexOfAny (Char [], Int32, Int32)
2207 public void IndexOfAny3_AnyOf_Null ()
2210 "mono".IndexOfAny ((char []) null, 0, 0);
2212 } catch (ArgumentNullException ex) {
2213 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2214 Assert.IsNull (ex.InnerException, "#3");
2215 Assert.IsNotNull (ex.Message, "#4");
2216 Assert.IsNull (ex.ParamName, "#5");
2220 [Test] // IndexOfAny (Char [], Int32, Int32)
2221 public void IndexOfAny3_Count_Negative ()
2224 "Mono".IndexOfAny (new char [1] { 'o' }, 1, -1);
2226 } catch (ArgumentOutOfRangeException ex) {
2227 // Count must be positive and count must refer to a
2228 // location within the string/array/collection
2229 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2230 Assert.IsNull (ex.InnerException, "#3");
2231 Assert.IsNotNull (ex.Message, "#4");
2232 Assert.AreEqual ("count", ex.ParamName, "#5");
2236 [Test] // IndexOfAny (Char [], Int32, Int32)
2237 public void IndexOfAny3_Length_Overflow ()
2239 string s = "abcdefghijklm";
2242 s.IndexOfAny (new char [1] { 'd' }, 1, s.Length);
2244 } catch (ArgumentOutOfRangeException ex) {
2245 // Count must be positive and count must refer to a
2246 // location within the string/array/collection
2247 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2248 Assert.IsNull (ex.InnerException, "#3");
2249 Assert.IsNotNull (ex.Message, "#4");
2250 Assert.AreEqual ("count", ex.ParamName, "#5");
2254 [Test] // IndexOfAny (Char [], Int32, Int32)
2255 public void IndexOfAny3_StartIndex_Negative ()
2258 "Mono".IndexOfAny (new char [1] { 'o' }, -1, 1);
2260 } catch (ArgumentOutOfRangeException ex) {
2261 // Specified argument was out of the range of valid
2263 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2264 Assert.IsNull (ex.InnerException, "#3");
2265 Assert.IsNotNull (ex.Message, "#4");
2266 Assert.IsNull (ex.ParamName, "#5");
2270 [Test] // IndexOfAny (Char [], Int32, Int32)
2271 public void IndexOfAny3_StartIndex_Overflow ()
2273 string s = "abcdefghijklm";
2276 s.IndexOfAny (new char [1] { 'o' }, s.Length + 1, 1);
2278 } catch (ArgumentOutOfRangeException ex) {
2279 // Specified argument was out of the range of valid
2281 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2282 Assert.IsNull (ex.InnerException, "#3");
2283 Assert.IsNotNull (ex.Message, "#4");
2284 Assert.IsNull (ex.ParamName, "#5");
2289 public void Contains ()
2291 Assert.IsTrue ("ABC".Contains (string.Empty));
2292 Assert.IsTrue ("ABC".Contains ("ABC"));
2293 Assert.IsTrue ("ABC".Contains ("AB"));
2294 Assert.IsTrue (!"ABC".Contains ("AD"));
2295 Assert.IsTrue (!"encyclopædia".Contains("encyclopaedia"));
2299 public void IndexOfIsCultureAwareWhileContainsIsNot ()
2301 string a = "encyclopædia";
2302 string b = "encyclopaedia";
2303 Assert.IsFalse (a.Contains (b), "#1");
2304 Assert.IsTrue (a.Contains ("æ"), "#1.1");
2305 Assert.IsFalse (b.Contains ("æ"), "#1.2");
2306 Assert.AreEqual (0, a.IndexOf (b), "#2");
2307 Assert.AreEqual (8, a.IndexOf ('æ'), "#3");
2308 Assert.AreEqual (-1, b.IndexOf ('æ'), "#4");
2309 Assert.AreEqual (8, a.IndexOf ("æ"), "#5");
2310 Assert.AreEqual (8, b.IndexOf ("æ"), "#6");
2312 Assert.AreEqual (0, CultureInfo.CurrentCulture.CompareInfo.IndexOf (a, b, 0, a.Length, CompareOptions.None), "#7");
2313 Assert.AreEqual (-1, CultureInfo.CurrentCulture.CompareInfo.IndexOf (a, b, 0, a.Length, CompareOptions.Ordinal), "#8");
2317 public void Contains_Value_Null ()
2320 "ABC".Contains (null);
2322 } catch (ArgumentNullException ex) {
2323 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2324 Assert.IsNull (ex.InnerException, "#3");
2325 Assert.IsNotNull (ex.Message, "#4");
2326 Assert.AreEqual ("value", ex.ParamName, "#5");
2331 public void IsNullOrEmpty ()
2333 Assert.IsTrue (String.IsNullOrEmpty (null));
2334 Assert.IsTrue (String.IsNullOrEmpty (String.Empty));
2335 Assert.IsTrue (String.IsNullOrEmpty (""));
2336 Assert.IsTrue (!String.IsNullOrEmpty ("A"));
2337 Assert.IsTrue (!String.IsNullOrEmpty (" "));
2338 Assert.IsTrue (!String.IsNullOrEmpty ("\t"));
2339 Assert.IsTrue (!String.IsNullOrEmpty ("\n"));
2343 public void TestInsert ()
2345 string s1 = "original";
2348 s1.Insert (0, null);
2349 Assert.Fail ("#A1");
2350 } catch (ArgumentNullException ex) {
2351 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2352 Assert.IsNull (ex.InnerException, "#A3");
2353 Assert.IsNotNull (ex.Message, "#A4");
2354 Assert.AreEqual ("value", ex.ParamName, "#A5");
2358 s1.Insert (s1.Length + 1, "Hi!");
2359 Assert.Fail ("#B1");
2360 } catch (ArgumentOutOfRangeException ex) {
2361 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
2362 Assert.IsNull (ex.InnerException, "#B3");
2363 Assert.IsNotNull (ex.Message, "#B4");
2364 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
2367 Assert.AreEqual ("Hi!original", s1.Insert (0, "Hi!"), "#C1");
2368 Assert.AreEqual ("originalHi!", s1.Insert (s1.Length, "Hi!"), "#C2");
2369 Assert.AreEqual ("origHi!inal", s1.Insert (4, "Hi!"), "#C3");
2373 public void Intern ()
2375 string s1 = "original";
2376 Assert.AreSame (s1, String.Intern (s1), "#A1");
2377 Assert.AreSame (String.Intern(s1), String.Intern(s1), "#A2");
2379 string s2 = "originally";
2380 Assert.AreSame (s2, String.Intern (s2), "#B1");
2381 Assert.IsTrue (String.Intern(s1) != String.Intern(s2), "#B2");
2383 string s3 = new DateTime (2000, 3, 7).ToString ();
2384 Assert.IsNull (String.IsInterned (s3), "#C1");
2386 string s4 = String.Intern (s3);
2387 Assert.AreEqual (s3, s4, "#C2");
2388 Assert.AreSame (s4, String.IsInterned (s4), "#C3");
2389 Assert.AreSame (s4, String.IsInterned (new DateTime (2000, 3, 7).ToString ()), "#C4");
2390 Assert.AreSame (s4, String.Intern (new DateTime (2000, 3, 7).ToString ()), "#C5");
2394 public void Intern_Str_Null ()
2397 String.Intern (null);
2399 } catch (ArgumentNullException ex) {
2400 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2401 Assert.IsNull (ex.InnerException, "#3");
2402 Assert.IsNotNull (ex.Message, "#4");
2403 Assert.AreEqual ("str", ex.ParamName, "#5");
2408 public void IsInterned ()
2410 Assert.IsNull (String.IsInterned (new DateTime (2000, 3, 6).ToString ()), "#1");
2411 string s1 = "original";
2412 Assert.AreSame (s1, String.IsInterned (s1), "#2");
2416 public void IsInterned_Str_Null ()
2419 String.IsInterned (null);
2421 } catch (ArgumentNullException ex) {
2422 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2423 Assert.IsNull (ex.InnerException, "#3");
2424 Assert.IsNotNull (ex.Message, "#4");
2425 Assert.AreEqual ("str", ex.ParamName, "#5");
2430 public void TestJoin ()
2433 string s = String.Join(" ", null);
2434 Assert.Fail ("#A1");
2435 } catch (ArgumentNullException ex) {
2436 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2437 Assert.IsNull (ex.InnerException, "#A3");
2438 Assert.IsNotNull (ex.Message, "#A4");
2439 Assert.AreEqual ("value", ex.ParamName, "#A5");
2442 string[] chunks = {"this", "is", "a", "test"};
2443 Assert.AreEqual ("this is a test", String.Join(" ", chunks), "Basic join");
2444 Assert.AreEqual ("this.is.a.test", String.Join(".", chunks), "Basic join");
2446 Assert.AreEqual ("is a", String.Join(" ", chunks, 1, 2), "Subset join");
2447 Assert.AreEqual ("is.a", String.Join(".", chunks, 1, 2), "Subset join");
2448 Assert.AreEqual ("is a test", String.Join(" ", chunks, 1, 3), "Subset join");
2451 string s = String.Join(" ", chunks, 2, 3);
2452 Assert.Fail ("#C1");
2453 } catch (ArgumentOutOfRangeException ex) {
2454 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
2455 Assert.IsNull (ex.InnerException, "#C3");
2456 Assert.IsNotNull (ex.Message, "#C4");
2457 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
2462 public void Join_SeparatorNull ()
2464 string[] chunks = {"this", "is", "a", "test"};
2465 Assert.AreEqual ("thisisatest", String.Join (null, chunks), "SeparatorNull");
2469 public void Join_ValuesNull ()
2471 string[] chunks1 = {null, "is", "a", null};
2472 Assert.AreEqual (" is a ", String.Join (" ", chunks1), "SomeNull");
2474 string[] chunks2 = {null, "is", "a", null};
2475 Assert.AreEqual ("isa", String.Join (null, chunks2), "Some+Sep=Null");
2477 string[] chunks3 = {null, null, null, null};
2478 Assert.AreEqual (" ", String.Join (" ", chunks3), "AllValuesNull");
2482 public void Join_AllNull ()
2484 string[] chunks = {null, null, null};
2485 Assert.AreEqual (string.Empty, String.Join (null, chunks), "AllNull");
2489 public void Join_StartIndexNegative ()
2491 string[] values = { "Mo", "no" };
2493 String.Join ("o", values, -1, 1);
2495 } catch (ArgumentOutOfRangeException ex) {
2496 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2497 Assert.IsNull (ex.InnerException, "#3");
2498 Assert.IsNotNull (ex.Message, "#4");
2499 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2504 public void Join_StartIndexOverflow ()
2506 string[] values = { "Mo", "no" };
2508 String.Join ("o", values, Int32.MaxValue, 1);
2510 } catch (ArgumentOutOfRangeException ex) {
2511 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2512 Assert.IsNull (ex.InnerException, "#3");
2513 Assert.IsNotNull (ex.Message, "#4");
2514 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2519 public void Join_LengthNegative ()
2521 string[] values = { "Mo", "no" };
2523 String.Join ("o", values, 1, -1);
2525 } catch (ArgumentOutOfRangeException ex) {
2526 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2527 Assert.IsNull (ex.InnerException, "#3");
2528 Assert.IsNotNull (ex.Message, "#4");
2529 Assert.AreEqual ("count", ex.ParamName, "#5");
2534 public void Join_LengthOverflow ()
2536 string[] values = { "Mo", "no" };
2538 String.Join ("o", values, 1, Int32.MaxValue);
2540 } catch (ArgumentOutOfRangeException ex) {
2541 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2542 Assert.IsNull (ex.InnerException, "#3");
2543 Assert.IsNotNull (ex.Message, "#4");
2544 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2549 public void LastIndexOf ()
2551 string s1 = "original";
2554 s1.LastIndexOf ('q', -1);
2555 Assert.Fail ("#A1");
2556 } catch (ArgumentOutOfRangeException ex) {
2557 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
2558 Assert.IsNull (ex.InnerException, "#A3");
2559 Assert.IsNotNull (ex.Message, "#A4");
2560 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
2564 s1.LastIndexOf ('q', -1, 1);
2565 Assert.Fail ("#B1");
2566 } catch (ArgumentOutOfRangeException ex) {
2567 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
2568 Assert.IsNull (ex.InnerException, "#B3");
2569 Assert.IsNotNull (ex.Message, "#B4");
2570 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
2574 s1.LastIndexOf ("huh", s1.Length + 1);
2575 Assert.Fail ("#C1");
2576 } catch (ArgumentOutOfRangeException ex) {
2577 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
2578 Assert.IsNull (ex.InnerException, "#C3");
2579 Assert.IsNotNull (ex.Message, "#C4");
2580 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
2584 int i = s1.LastIndexOf ("huh", s1.Length + 1, 3);
2585 Assert.Fail ("#D1");
2586 } catch (ArgumentOutOfRangeException ex) {
2587 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
2588 Assert.IsNull (ex.InnerException, "#D3");
2589 Assert.IsNotNull (ex.Message, "#D4");
2590 Assert.AreEqual ("startIndex", ex.ParamName, "#D5");
2594 s1.LastIndexOf (null);
2595 Assert.Fail ("#E1");
2596 } catch (ArgumentNullException ex) {
2597 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#E2");
2598 Assert.IsNull (ex.InnerException, "#E3");
2599 Assert.IsNotNull (ex.Message, "#E4");
2600 Assert.AreEqual ("value", ex.ParamName, "#E5");
2604 s1.LastIndexOf (null, 0);
2605 Assert.Fail ("#F1");
2606 } catch (ArgumentNullException ex) {
2607 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#F2");
2608 Assert.IsNull (ex.InnerException, "#F3");
2609 Assert.IsNotNull (ex.Message, "#F4");
2610 Assert.AreEqual ("value", ex.ParamName, "#F5");
2614 s1.LastIndexOf (null, 0, 1);
2615 Assert.Fail ("#G1");
2616 } catch (ArgumentNullException ex) {
2617 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#G2");
2618 Assert.IsNull (ex.InnerException, "#G3");
2619 Assert.IsNotNull (ex.Message, "#G4");
2620 Assert.AreEqual ("value", ex.ParamName, "#G5");
2623 Assert.AreEqual (1, s1.LastIndexOf('r'), "basic char index");
2624 Assert.AreEqual (4, s1.LastIndexOf('i'), "basic char index");
2625 Assert.AreEqual (-1, s1.LastIndexOf('q'), "basic char index - no");
2627 Assert.AreEqual (7, s1.LastIndexOf(string.Empty), "basic string index");
2628 Assert.AreEqual (1, s1.LastIndexOf("rig"), "basic string index");
2629 Assert.AreEqual (4, s1.LastIndexOf("i"), "basic string index");
2630 Assert.AreEqual (-1, s1.LastIndexOf("rag"), "basic string index - no");
2632 Assert.AreEqual (1, s1.LastIndexOf('r', s1.Length-1), "stepped char index");
2633 Assert.AreEqual (4, s1.LastIndexOf('i', s1.Length-1), "stepped char index");
2634 Assert.AreEqual (2, s1.LastIndexOf('i', 3), "stepped char index");
2635 Assert.AreEqual (-1, s1.LastIndexOf('i', 1), "stepped char index");
2637 Assert.AreEqual (1, s1.LastIndexOf('r', 1, 1), "stepped limited char index");
2638 Assert.AreEqual (-1, s1.LastIndexOf('r', 0, 1), "stepped limited char index");
2639 Assert.AreEqual (4, s1.LastIndexOf('i', 6, 3), "stepped limited char index");
2640 Assert.AreEqual (2, s1.LastIndexOf('i', 3, 3), "stepped limited char index");
2641 Assert.AreEqual (-1, s1.LastIndexOf('i', 1, 2), "stepped limited char index");
2643 s1 = "original original";
2644 Assert.AreEqual (9, s1.LastIndexOf("original", s1.Length), "stepped string index #1");
2645 Assert.AreEqual (0, s1.LastIndexOf("original", s1.Length-2), "stepped string index #2");
2646 Assert.AreEqual (-1, s1.LastIndexOf("original", s1.Length-11), "stepped string index #3");
2647 Assert.AreEqual (-1, s1.LastIndexOf("translator", 2), "stepped string index #4");
2648 Assert.AreEqual (0, string.Empty.LastIndexOf(string.Empty, 0), "stepped string index #5");
2649 Assert.AreEqual (-1, string.Empty.LastIndexOf("A", -1), "stepped string index #6");
2650 Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-1, 10), "stepped limited string index #1");
2651 Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length, 3), "stepped limited string index #2");
2652 Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-2, 15), "stepped limited string index #3");
2653 Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length-2, 3), "stepped limited string index #4");
2655 string s2 = "QBitArray::bitarr_data";
2656 Assert.AreEqual (9, s2.LastIndexOf ("::"), "bug #62160");
2658 string s3 = "test123";
2659 Assert.AreEqual (0, s3.LastIndexOf ("test123"), "bug #77412");
2661 Assert.AreEqual (0, "\u267B RT \u30FC".LastIndexOf ("\u267B RT "), "bug #605094");
2665 [ExpectedException (typeof (ArgumentException))]
2666 public void LastIndexOf_StringComparison ()
2668 " ".LastIndexOf (string.Empty, 0, 1, (StringComparison)Int32.MinValue);
2672 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2673 public void LastIndexOfStringComparisonOrdinalRangeException1 ()
2675 "Mono".LastIndexOf ("no", 5, StringComparison.Ordinal);
2679 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2680 public void LastIndexOfStringComparisonOrdinalRangeException2 ()
2682 "Mono".LastIndexOf ("no", 1, 3, StringComparison.Ordinal);
2686 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2687 public void LastIndexOfStringComparisonOrdinalIgnoreCaseRangeException1 ()
2689 "Mono".LastIndexOf ("no", 5, StringComparison.OrdinalIgnoreCase);
2693 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2694 public void LastIndexOfStringComparisonOrdinalIgnoreCaseRangeException2 ()
2696 "Mono".LastIndexOf ("no", 1, 3, StringComparison.OrdinalIgnoreCase);
2700 public void LastIndexOfStringComparison ()
2702 string text = "testing123456";
2703 string text2 = "123";
2704 string text3 = "NG";
2706 Assert.AreEqual (7, text.LastIndexOf (text2, StringComparison.Ordinal), "#1-1");
2707 Assert.AreEqual (5, text.LastIndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1");
2709 Assert.AreEqual (7, text.LastIndexOf (text2, 12, StringComparison.Ordinal), "#1-2");
2710 Assert.AreEqual (5, text.LastIndexOf (text3, 12, StringComparison.OrdinalIgnoreCase), "#2-2");
2712 Assert.AreEqual (-1, text.LastIndexOf (text2, 0, StringComparison.Ordinal), "#1-3");
2713 Assert.AreEqual (-1, text.LastIndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-3");
2715 Assert.AreEqual (-1, text.LastIndexOf (text2, 6, StringComparison.Ordinal), "#1-4");
2716 Assert.AreEqual (5, text.LastIndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4");
2718 Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5");
2719 Assert.AreEqual (5, text.LastIndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5");
2721 Assert.AreEqual (-1, text.LastIndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6");
2722 Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6");
2724 Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7");
2725 Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7");
2727 Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.Ordinal), "#3-1");
2728 Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2");
2730 Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.Ordinal), "#4-1");
2731 Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2");
2733 Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.Ordinal), "#4-1");
2734 Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.OrdinalIgnoreCase), "#4-2");
2736 Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.Ordinal), "#5-1");
2737 Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.OrdinalIgnoreCase), "#5-2");
2739 Assert.AreEqual (-1, "".LastIndexOf ("FOO", StringComparison.Ordinal));
2740 Assert.AreEqual (0, "".LastIndexOf ("", StringComparison.Ordinal));
2744 public void LastIndexOfStringComparisonOrdinal ()
2746 string text = "testing123456";
2747 Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.Ordinal), "#1");
2748 Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.Ordinal), "#2");
2749 Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.Ordinal), "#3");
2750 Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.Ordinal), "#4");
2751 Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.Ordinal), "#5");
2752 Assert.AreEqual (-1, text.LastIndexOf ("S", StringComparison.Ordinal), "#6");
2756 public void LastIndexOfStringComparisonOrdinalIgnoreCase ()
2758 string text = "testing123456";
2759 Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1");
2760 Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2");
2761 Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3");
2762 Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4");
2763 Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5");
2764 Assert.AreEqual (2, text.LastIndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6");
2768 public void LastIndexOf_Char_StartIndexStringLength ()
2772 s.LastIndexOf ('n', s.Length, 1);
2774 } catch (ArgumentOutOfRangeException ex) {
2775 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2776 Assert.IsNull (ex.InnerException, "#3");
2777 Assert.IsNotNull (ex.Message, "#4");
2778 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2780 // this works for string but not for a char
2784 public void LastIndexOf_Char_StartIndexOverflow ()
2787 "Mono".LastIndexOf ('o', Int32.MaxValue, 1);
2789 } catch (ArgumentOutOfRangeException ex) {
2790 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2791 Assert.IsNull (ex.InnerException, "#3");
2792 Assert.IsNotNull (ex.Message, "#4");
2793 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2798 public void LastIndexOf_Char_LengthOverflow ()
2801 "Mono".LastIndexOf ('o', 1, Int32.MaxValue);
2803 } catch (ArgumentOutOfRangeException ex) {
2804 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2805 Assert.IsNull (ex.InnerException, "#3");
2806 Assert.IsNotNull (ex.Message, "#4");
2807 Assert.AreEqual ("count", ex.ParamName, "#5");
2812 public void LastIndexOf_String_StartIndexStringLength ()
2815 Assert.AreEqual (-1, s.LastIndexOf ("n", s.Length, 1));
2816 // this works for string but not for a char
2820 public void LastIndexOf_String_StartIndexStringLength_Plus1 ()
2824 s.LastIndexOf ("n", s.Length + 1, 1);
2826 } catch (ArgumentOutOfRangeException ex) {
2827 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2828 Assert.IsNull (ex.InnerException, "#3");
2829 Assert.IsNotNull (ex.Message, "#4");
2830 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2835 public void LastIndexOf_String_StartIndexOverflow ()
2838 "Mono".LastIndexOf ("no", Int32.MaxValue, 1);
2840 } catch (ArgumentOutOfRangeException ex) {
2841 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2842 Assert.IsNull (ex.InnerException, "#3");
2843 Assert.IsNotNull (ex.Message, "#4");
2844 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2849 public void LastIndexOf_String_LengthOverflow ()
2852 "Mono".LastIndexOf ("no", 1, Int32.MaxValue);
2854 } catch (ArgumentOutOfRangeException ex) {
2855 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2856 Assert.IsNull (ex.InnerException, "#3");
2857 Assert.IsNotNull (ex.Message, "#4");
2858 Assert.AreEqual ("count", ex.ParamName, "#5");
2863 public void LastIndexOfAny ()
2865 string s1 = ".bcdefghijklm";
2868 s1.LastIndexOfAny (null);
2869 Assert.Fail ("#A1");
2870 } catch (ArgumentNullException ex) {
2871 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2872 Assert.IsNull (ex.InnerException, "#A3");
2873 Assert.IsNotNull (ex.Message, "#A4");
2874 Assert.IsNull (ex.ParamName, "#A5");
2878 s1.LastIndexOfAny (null, s1.Length);
2879 Assert.Fail ("#B1");
2880 } catch (ArgumentNullException ex) {
2881 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
2882 Assert.IsNull (ex.InnerException, "#B3");
2883 Assert.IsNotNull (ex.Message, "#B4");
2884 Assert.IsNull (ex.ParamName, "#B5");
2888 s1.LastIndexOfAny (null, s1.Length, 1);
2889 Assert.Fail ("#C1");
2890 } catch (ArgumentNullException ex) {
2891 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
2892 Assert.IsNull (ex.InnerException, "#C3");
2893 Assert.IsNotNull (ex.Message, "#C4");
2894 Assert.IsNull (ex.ParamName, "#C5");
2897 char[] c1 = {'a', 'e', 'i', 'o', 'u'};
2898 Assert.AreEqual (8, s1.LastIndexOfAny (c1), "#D1");
2899 Assert.AreEqual (4, s1.LastIndexOfAny (c1, 7), "#D2");
2900 Assert.AreEqual (-1, s1.LastIndexOfAny (c1, 3), "#D3");
2901 Assert.AreEqual (4, s1.LastIndexOfAny (c1, s1.Length - 6, 4), "#D4");
2902 Assert.AreEqual (-1, s1.LastIndexOfAny (c1, s1.Length - 6, 3), "#D5");
2905 s1.LastIndexOfAny (c1, -1);
2906 Assert.Fail ("#E1");
2907 } catch (ArgumentOutOfRangeException ex) {
2908 // Index was out of range. Must be non-negative and
2909 // less than the size of the collection
2910 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2");
2911 Assert.IsNull (ex.InnerException, "#E3");
2912 Assert.IsNotNull (ex.Message, "#E4");
2913 Assert.AreEqual ("startIndex", ex.ParamName, "#E5");
2917 s1.LastIndexOfAny (c1, -1, 1);
2918 Assert.Fail ("#F1");
2919 } catch (ArgumentOutOfRangeException ex) {
2920 // Index was out of range. Must be non-negative and
2921 // less than the size of the collection
2922 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#F2");
2923 Assert.IsNull (ex.InnerException, "#F3");
2924 Assert.IsNotNull (ex.Message, "#F4");
2925 Assert.AreEqual ("startIndex", ex.ParamName, "#F5");
2930 public void LastIndexOfAny_Length_Overflow ()
2933 "Mono".LastIndexOfAny (new char [1] { 'o' }, 1, Int32.MaxValue);
2935 } catch (ArgumentOutOfRangeException ex) {
2936 // Count must be positive and count must refer to a
2937 // location within the string/array/collection
2938 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2939 Assert.IsNull (ex.InnerException, "#3");
2940 Assert.IsNotNull (ex.Message, "#4");
2941 Assert.AreEqual ("count", ex.ParamName, "#5");
2946 public void LastIndexOfAny_StartIndex_Overflow ()
2949 "Mono".LastIndexOfAny (new char [1] { 'o' }, Int32.MaxValue, 1);
2951 } catch (ArgumentOutOfRangeException ex) {
2952 // Index was out of range. Must be non-negative and
2953 // less than the size of the collection
2954 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2955 Assert.IsNull (ex.InnerException, "#3");
2956 Assert.IsNotNull (ex.Message, "#4");
2957 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2961 [Test] // PadLeft (Int32)
2962 public void PadLeft1 ()
2967 result = s1.PadLeft (0);
2968 Assert.AreSame (s1, result, "#A");
2970 result = s1.PadLeft (s1.Length - 1);
2971 Assert.AreSame (s1, result, "#B");
2973 result = s1.PadLeft (s1.Length);
2974 Assert.AreEqual (s1, result, "#C1");
2975 Assert.IsTrue (object.ReferenceEquals (s1, result), "#C2");
2977 result = s1.PadLeft (s1.Length + 1);
2978 Assert.AreEqual (" Hi!", result, "#D");
2981 [Test] // PadLeft (Int32)
2982 public void PadLeft1_TotalWidth_Negative ()
2985 "Mono".PadLeft (-1);
2987 } catch (ArgumentOutOfRangeException ex) {
2988 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2989 Assert.IsNull (ex.InnerException, "#3");
2990 Assert.IsNotNull (ex.Message, "#4");
2991 Assert.AreEqual ("totalWidth", ex.ParamName, "#5");
2996 public void PadLeft_Overflow ()
2999 "x".PadLeft (int.MaxValue, '-');
3000 } catch (OutOfMemoryException) {
3004 [Test] // PadRight (Int32)
3005 public void PadRight1 ()
3010 result = s1.PadRight (0);
3011 Assert.AreSame (s1, result, "#A");
3013 result = s1.PadRight (s1.Length - 1);
3014 Assert.AreSame (s1, result, "#B");
3016 result = s1.PadRight (s1.Length);
3017 Assert.AreEqual (s1, result, "#C1");
3018 Assert.IsTrue (object.ReferenceEquals (s1, result), "#C2");
3020 result = s1.PadRight (s1.Length + 1);
3021 Assert.AreEqual ("Hi! ", result, "#D");
3024 [Test] // PadRight1 (Int32)
3025 public void PadRight1_TotalWidth_Negative ()
3028 "Mono".PadRight (-1);
3030 } catch (ArgumentOutOfRangeException ex) {
3031 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3032 Assert.IsNull (ex.InnerException, "#3");
3033 Assert.IsNotNull (ex.Message, "#4");
3034 Assert.AreEqual ("totalWidth", ex.ParamName, "#5");
3039 public void PadRight2 ()
3041 Assert.AreEqual ("100000000000", "1".PadRight (12, '0'), "#1");
3042 Assert.AreEqual ("000000000000", "".PadRight (12, '0'), "#2");
3046 public void PadRight_Overflow ()
3049 "x".PadRight (int.MaxValue, '-');
3050 } catch (OutOfMemoryException) {
3054 [Test] // Remove (Int32, Int32)
3055 public void Remove2 ()
3057 string s1 = "original";
3061 Assert.Fail ("#A1");
3062 } catch (ArgumentOutOfRangeException ex) {
3063 // StartIndex cannot be less than zero
3064 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3065 Assert.IsNull (ex.InnerException, "#A3");
3066 Assert.IsNotNull (ex.Message, "#A4");
3067 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3072 Assert.Fail ("#B1");
3073 } catch (ArgumentOutOfRangeException ex) {
3074 // Count cannot be less than zero
3075 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3076 Assert.IsNull (ex.InnerException, "#B3");
3077 Assert.IsNotNull (ex.Message, "#B4");
3078 Assert.AreEqual ("count", ex.ParamName, "#B5");
3082 s1.Remove (s1.Length, s1.Length);
3083 Assert.Fail ("#C1");
3084 } catch (ArgumentOutOfRangeException ex) {
3085 // Index and count must refer to a location within the
3087 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
3088 Assert.IsNull (ex.InnerException, "#C3");
3089 Assert.IsNotNull (ex.Message, "#C4");
3090 Assert.AreEqual ("count", ex.ParamName, "#C5");
3093 Assert.AreEqual ("oinal", s1.Remove(1, 3), "#D1");
3094 Assert.AreEqual (s1, s1.Remove (0, 0), "#D2");
3095 Assert.IsTrue (!object.ReferenceEquals (s1, s1.Remove (0, 0)), "#D3");
3096 Assert.AreEqual ("riginal", s1.Remove (0, 1), "#D4");
3097 Assert.AreEqual ("origina", s1.Remove (7, 1), "#D5");
3100 [Test] // Remove (Int32, Int32)
3101 public void Remove2_Length_Overflow ()
3104 "Mono".Remove (1, Int32.MaxValue);
3106 } catch (ArgumentOutOfRangeException ex) {
3107 // Index and count must refer to a location within the
3109 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3110 Assert.IsNull (ex.InnerException, "#3");
3111 Assert.IsNotNull (ex.Message, "#4");
3112 Assert.AreEqual ("count", ex.ParamName, "#5");
3116 [Test] // Remove (Int32, Int32)
3117 public void Remove2_StartIndex_Overflow ()
3120 "Mono".Remove (Int32.MaxValue, 1);
3122 } catch (ArgumentOutOfRangeException ex) {
3123 // Index and count must refer to a location within the
3125 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3126 Assert.IsNull (ex.InnerException, "#3");
3127 Assert.IsNotNull (ex.Message, "#4");
3128 Assert.AreEqual ("count", ex.ParamName, "#5");
3132 [Test] // Remove (Int32)
3133 public void Remove1_StartIndex_Negative ()
3138 } catch (ArgumentOutOfRangeException ex) {
3139 // StartIndex cannot be less than zero
3140 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3141 Assert.IsNull (ex.InnerException, "#3");
3142 Assert.IsNotNull (ex.Message, "#4");
3143 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3147 [Test] // Remove (Int32)
3148 public void Remove1_StartIndex_Overflow ()
3153 } catch (ArgumentOutOfRangeException ex) {
3154 // startIndex must be less than length of string
3155 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3156 Assert.IsNull (ex.InnerException, "#3");
3157 Assert.IsNotNull (ex.Message, "#4");
3158 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3162 [Test] // Remove (Int32)
3163 public void Remove1 ()
3167 Assert.AreEqual ("AB", s.Remove (2), "#1");
3168 Assert.AreEqual (string.Empty, s.Remove (0), "#2");
3169 Assert.AreEqual ("A", s.Remove (1), "#3");
3173 public void Replace()
3175 string s1 = "original";
3177 Assert.AreEqual (s1, s1.Replace('q', 's'), "non-hit char");
3178 Assert.AreEqual ("oxiginal", s1.Replace('r', 'x'), "single char");
3179 Assert.AreEqual ("orxgxnal", s1.Replace('i', 'x'), "double char");
3181 bool errorThrown = false;
3183 string s = s1.Replace(null, "feh");
3184 } catch (ArgumentNullException) {
3187 Assert.IsTrue (errorThrown, "should get null arg exception");
3189 Assert.AreEqual ("ornal", s1.Replace("igi", null), "replace as remove");
3190 Assert.AreEqual (s1, s1.Replace("spam", "eggs"), "non-hit string");
3191 Assert.AreEqual ("orirumal", s1.Replace("gin", "rum"), "single string");
3192 Assert.AreEqual ("oreigeinal", s1.Replace("i", "ei"), "double string");
3194 Assert.AreEqual ("ooriginal", s1.Replace("o", "oo"), "start");
3195 Assert.AreEqual ("originall", s1.Replace("l", "ll"), "end");
3197 Assert.AreEqual ("riginal", s1.Replace("o", string.Empty), "start empty");
3198 Assert.AreEqual ("origina", s1.Replace("l", string.Empty), "end empty");
3200 Assert.AreEqual ("original", s1.Replace("original2", "original3"), "replace bigger that original");
3202 Assert.AreEqual (":!:", "::".Replace ("::", ":!:"), "result longer");
3204 // Test overlapping matches (bug #54988)
3205 string s2 = "...aaaaaaa.bbbbbbbbb,............ccccccc.u...";
3206 Assert.AreEqual (s2.Replace("..", "."), "..aaaaaaa.bbbbbbbbb,......ccccccc.u..");
3208 // Test replacing null characters (bug #67395)
3209 Assert.AreEqual ("is this ok ?", "is \0 ok ?".Replace ("\0", "this"), "should not strip content after nullchar");
3213 public void ReplaceStringBeginEndTest ()
3215 string s1 = "original";
3217 Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1");
3218 Assert.AreEqual ("origina", s1.Replace ("l", ""), "#2");
3219 Assert.AreEqual ("ariginal", s1.Replace ("o", "a"), "#3");
3220 Assert.AreEqual ("originaa", s1.Replace ("l", "a"), "#4");
3221 Assert.AreEqual ("aariginal", s1.Replace ("o", "aa"), "#5");
3222 Assert.AreEqual ("originaaa", s1.Replace ("l", "aa"), "#6");
3223 Assert.AreEqual ("original", s1.Replace ("o", "o"), "#7");
3224 Assert.AreEqual ("original", s1.Replace ("l", "l"), "#8");
3225 Assert.AreEqual ("original", s1.Replace ("original", "original"), "#9");
3226 Assert.AreEqual ("", s1.Replace ("original", ""), "#10");
3230 public void ReplaceStringBeginEndTestFallback ()
3232 string prev = new String ('o', 300);
3233 string s1 = prev + "riginal";
3235 Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1");
3236 Assert.AreEqual (prev + "rigina", s1.Replace ("l", ""), "#2");
3237 Assert.AreEqual (new String ('a', 300) + "riginal", s1.Replace ("o", "a"), "#3");
3238 Assert.AreEqual (prev + "riginaa", s1.Replace ("l", "a"), "#4");
3239 Assert.AreEqual (new String ('a', 600) + "riginal", s1.Replace ("o", "aa"), "#5");
3240 Assert.AreEqual (prev + "riginaaa", s1.Replace ("l", "aa"), "#6");
3241 Assert.AreEqual (s1, s1.Replace ("o", "o"), "#7");
3242 Assert.AreEqual (s1, s1.Replace ("l", "l"), "#8");
3243 Assert.AreEqual (s1, s1.Replace (s1, s1), "#9");
3244 Assert.AreEqual ("", s1.Replace (prev + "riginal", ""), "#10");
3248 public void ReplaceStringOffByOne ()
3250 Assert.AreEqual ("", new String ('o', 199).Replace ("o", ""), "#-1");
3251 Assert.AreEqual ("", new String ('o', 200).Replace ("o", ""), "#0");
3252 Assert.AreEqual ("", new String ('o', 201).Replace ("o", ""), "#+1");
3256 public void ReplaceStringCultureTests ()
3258 // LAMESPEC: According to MSDN Replace with String parameter is culture-senstive.
3259 // However this does not currently seem to be the case. Otherwise following code should
3260 // produce "check" instead of "AE"
3262 CultureInfo old = Thread.CurrentThread.CurrentCulture;
3263 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3264 Assert.AreEqual ("AE", "AE".Replace ("\u00C6", "check"), "#1");
3265 Thread.CurrentThread.CurrentCulture = old;
3268 [Test] // StartsWith (String)
3269 public void StartsWith1 ()
3271 string s1 = "original";
3273 Assert.IsTrue (s1.StartsWith ("o"), "#1");
3274 Assert.IsTrue (s1.StartsWith ("orig"), "#2");
3275 Assert.IsTrue (!s1.StartsWith ("rig"), "#3");
3276 Assert.IsTrue (s1.StartsWith (String.Empty), "#4");
3277 Assert.IsTrue (String.Empty.StartsWith (String.Empty), "#5");
3278 Assert.IsTrue (!String.Empty.StartsWith ("rig"), "#6");
3281 [Test] // StartsWith (String)
3282 public void StartsWith1_Value_Null ()
3285 "A".StartsWith (null);
3287 } catch (ArgumentNullException ex) {
3288 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3289 Assert.IsNull (ex.InnerException, "#3");
3290 Assert.IsNotNull (ex.Message, "#4");
3291 Assert.AreEqual ("value", ex.ParamName, "#5");
3295 [Test] // StartsWith (String, StringComparison)
3296 public void StartsWith2_ComparisonType_Invalid ()
3299 "ABC".StartsWith ("A", (StringComparison) 80);
3301 } catch (ArgumentException ex) {
3302 // The string comparison type passed in is currently
3304 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3305 Assert.IsNull (ex.InnerException, "#3");
3306 Assert.IsNotNull (ex.Message, "#4");
3307 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
3311 [Test] // StartsWith (String, StringComparison)
3312 public void StartsWith2_Value_Null ()
3315 "A".StartsWith (null, StringComparison.CurrentCulture);
3317 } catch (ArgumentNullException ex) {
3318 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3319 Assert.IsNull (ex.InnerException, "#3");
3320 Assert.IsNotNull (ex.Message, "#4");
3321 Assert.AreEqual ("value", ex.ParamName, "#5");
3325 [Test] // StartsWith (String, Boolean, CultureInfo)
3326 public void StartsWith3_Culture_Null ()
3328 // This should not crash
3331 s.StartsWith ("this", true, null);
3334 [Test] // SubString (Int32)
3335 public void Substring1 ()
3337 string s = "original";
3339 Assert.AreEqual ("inal", s.Substring (4), "#1");
3340 Assert.AreEqual (string.Empty, s.Substring (s.Length), "#2");
3341 Assert.AreSame (s, s.Substring (0), "#3");
3344 [Test] // SubString (Int32)
3345 public void SubString1_StartIndex_Negative ()
3347 string s = "original";
3352 } catch (ArgumentOutOfRangeException ex) {
3353 // StartIndex cannot be less than zero
3354 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3355 Assert.IsNull (ex.InnerException, "#3");
3356 Assert.IsNotNull (ex.Message, "#4");
3357 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3361 [Test] // SubString (Int32)
3362 public void SubString1_StartIndex_Overflow ()
3364 string s = "original";
3367 s.Substring (s.Length + 1);
3369 } catch (ArgumentOutOfRangeException ex) {
3370 // startIndex cannot be larger than length of string
3371 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3372 Assert.IsNull (ex.InnerException, "#3");
3373 Assert.IsNotNull (ex.Message, "#4");
3374 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3378 [Test] // SubString (Int32, Int32)
3379 public void Substring2 ()
3381 string s = "original";
3383 Assert.AreEqual ("igin", s.Substring (2, 4), "#1");
3384 Assert.AreEqual (string.Empty, s.Substring (s.Length, 0), "#2");
3385 Assert.AreEqual ("origina", s.Substring (0, s.Length - 1), "#3");
3386 Assert.AreEqual (s, s.Substring (0, s.Length), "#4");
3387 Assert.AreSame (s, s.Substring (0, s.Length), "#5");
3390 [Test] // SubString (Int32, Int32)
3391 public void SubString2_Length_Negative ()
3393 string s = "original";
3396 s.Substring (1, -1);
3398 } catch (ArgumentOutOfRangeException ex) {
3399 // Length cannot be less than zero
3400 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3401 Assert.IsNull (ex.InnerException, "#3");
3402 Assert.IsNotNull (ex.Message, "#4");
3403 Assert.AreEqual ("length", ex.ParamName, "#5");
3407 [Test] // SubString (Int32, Int32)
3408 public void Substring2_Length_Overflow ()
3410 string s = "original";
3413 s.Substring (s.Length, 1);
3414 Assert.Fail ("#A1");
3415 } catch (ArgumentOutOfRangeException ex) {
3416 // Index and length must refer to a location within
3418 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3419 Assert.IsNull (ex.InnerException, "#A3");
3420 Assert.IsNotNull (ex.Message, "#A4");
3421 Assert.AreEqual ("length", ex.ParamName, "#A5");
3425 s.Substring (1, s.Length);
3426 Assert.Fail ("#B1");
3427 } catch (ArgumentOutOfRangeException ex) {
3428 // Index and length must refer to a location within
3430 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3431 Assert.IsNull (ex.InnerException, "#B3");
3432 Assert.IsNotNull (ex.Message, "#B4");
3433 Assert.AreEqual ("length", ex.ParamName, "#B5");
3437 s.Substring (1, Int32.MaxValue);
3438 Assert.Fail ("#C1");
3439 } catch (ArgumentOutOfRangeException ex) {
3440 // Index and length must refer to a location within
3442 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
3443 Assert.IsNull (ex.InnerException, "#C3");
3444 Assert.IsNotNull (ex.Message, "#C4");
3445 Assert.AreEqual ("length", ex.ParamName, "#C5");
3449 [Test] // SubString (Int32, Int32)
3450 public void SubString2_StartIndex_Negative ()
3452 string s = "original";
3455 s.Substring (-1, 1);
3457 } catch (ArgumentOutOfRangeException ex) {
3458 // StartIndex cannot be less than zero
3459 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3460 Assert.IsNull (ex.InnerException, "#3");
3461 Assert.IsNotNull (ex.Message, "#4");
3462 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3466 [Test] // SubString (Int32, Int32)
3467 public void Substring2_StartIndex_Overflow ()
3469 string s = "original";
3472 s.Substring (s.Length + 1, 0);
3473 Assert.Fail ("#A1");
3474 } catch (ArgumentOutOfRangeException ex) {
3475 // startIndex cannot be larger than length of string
3476 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3477 Assert.IsNull (ex.InnerException, "#A3");
3478 Assert.IsNotNull (ex.Message, "#A4");
3479 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3483 "Mono".Substring (Int32.MaxValue, 1);
3484 Assert.Fail ("#B1");
3485 } catch (ArgumentOutOfRangeException ex) {
3486 // startIndex cannot be larger than length of string
3487 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3488 Assert.IsNull (ex.InnerException, "#B3");
3489 Assert.IsNotNull (ex.Message, "#B4");
3490 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3495 public void ToCharArray ()
3497 const string s = "original";
3500 c = s.ToCharArray ();
3501 Assert.AreEqual (s.Length, c.Length, "#A1");
3502 Assert.AreEqual (s, new String (c), "#A2");
3504 c = s.ToCharArray (0, s.Length);
3505 Assert.AreEqual (s.Length, c.Length, "#B1");
3506 Assert.AreEqual (s, new String (c), "#B2");
3508 c = s.ToCharArray (1, s.Length - 1);
3509 Assert.AreEqual (7, c.Length, "#C1");
3510 Assert.AreEqual ("riginal", new String (c), "#C2");
3512 c = s.ToCharArray (0, 3);
3513 Assert.AreEqual (3, c.Length, "#D1");
3514 Assert.AreEqual ("ori", new String (c), "#D2");
3516 c = s.ToCharArray (2, 0);
3517 Assert.AreEqual (0, c.Length, "#E1");
3518 Assert.AreEqual (string.Empty, new String (c), "#E2");
3520 c = s.ToCharArray (3, 2);
3521 Assert.AreEqual (2, c.Length, "#F1");
3522 Assert.AreEqual ("gi", new String (c), "#F2");
3524 c = s.ToCharArray (s.Length, 0);
3525 Assert.AreEqual (0, c.Length, "#G1");
3526 Assert.AreEqual (string.Empty, new String (c), "#G2");
3530 public void ToCharArray_Length_Negative ()
3532 const string s = "original";
3535 s.ToCharArray (1, -1);
3537 } catch (ArgumentOutOfRangeException ex) {
3538 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3539 Assert.IsNull (ex.InnerException, "#3");
3540 Assert.IsNotNull (ex.Message, "#4");
3541 Assert.AreEqual ("length", ex.ParamName, "#5");
3546 public void ToCharArray_Length_Overflow ()
3548 const string s = "original";
3551 s.ToCharArray (1, s.Length);
3552 Assert.Fail ("#A1");
3553 } catch (ArgumentOutOfRangeException ex) {
3554 // Index was out of range. Must be non-negative and
3555 // less than the size of the collection
3556 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3557 Assert.IsNull (ex.InnerException, "#A3");
3558 Assert.IsNotNull (ex.Message, "#A4");
3559 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3563 s.ToCharArray (1, Int32.MaxValue);
3564 Assert.Fail ("#B1");
3565 } catch (ArgumentOutOfRangeException ex) {
3566 // Index was out of range. Must be non-negative and
3567 // less than the size of the collection
3568 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3569 Assert.IsNull (ex.InnerException, "#B3");
3570 Assert.IsNotNull (ex.Message, "#B4");
3571 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3576 public void ToCharArray_StartIndex_Negative ()
3578 const string s = "original";
3581 s.ToCharArray (-1, 1);
3583 } catch (ArgumentOutOfRangeException ex) {
3584 // Index was out of range. Must be non-negative and
3585 // less than the size of the collection
3586 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3587 Assert.IsNull (ex.InnerException, "#3");
3588 Assert.IsNotNull (ex.Message, "#4");
3589 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3594 public void ToCharArray_StartIndex_Overflow ()
3596 const string s = "original";
3599 s.ToCharArray (s.Length, 1);
3600 Assert.Fail ("#A1");
3601 } catch (ArgumentOutOfRangeException ex) {
3602 // Index was out of range. Must be non-negative and
3603 // less than the size of the collection
3604 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3605 Assert.IsNull (ex.InnerException, "#A3");
3606 Assert.IsNotNull (ex.Message, "#A4");
3607 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3611 s.ToCharArray (Int32.MaxValue, 1);
3612 Assert.Fail ("#B1");
3613 } catch (ArgumentOutOfRangeException ex) {
3614 // Index was out of range. Must be non-negative and
3615 // less than the size of the collection
3616 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3617 Assert.IsNull (ex.InnerException, "#B3");
3618 Assert.IsNotNull (ex.Message, "#B4");
3619 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3623 [Test] // ToLower ()
3624 public void ToLower1 ()
3626 string s = "OrIgInAli";
3628 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3630 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower(), "#1");
3632 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3634 Assert.AreEqual ("originali", s.ToLower (), "#2");
3637 [Test] // ToLower (CultureInfo)
3638 public void ToLower2 ()
3640 string s = "OrIgInAli";
3642 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3644 Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#A1");
3645 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#A2");
3646 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#A3");
3647 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#A4");
3649 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3651 Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#B1");
3652 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#B2");
3653 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#B3");
3654 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#B4");
3657 [Test] // ToLower (CultureInfo)
3658 public void ToLower2_Culture_Null ()
3660 string s = "OrIgInAl";
3663 s.ToLower ((CultureInfo) null);
3664 Assert.Fail ("#A1");
3665 } catch (ArgumentNullException ex) {
3666 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
3667 Assert.IsNull (ex.InnerException, "#A3");
3668 Assert.IsNotNull (ex.Message, "#A4");
3669 Assert.AreEqual ("culture", ex.ParamName, "#A5");
3673 string.Empty.ToLower ((CultureInfo) null);
3674 Assert.Fail ("#B1");
3675 } catch (ArgumentNullException ex) {
3676 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
3677 Assert.IsNull (ex.InnerException, "#B3");
3678 Assert.IsNotNull (ex.Message, "#B4");
3679 Assert.AreEqual ("culture", ex.ParamName, "#B5");
3684 public void TestToString ()
3686 string s1 = "OrIgInAli";
3687 Assert.AreEqual (s1, s1.ToString(), "ToString failed!");
3690 [Test] // ToUpper ()
3691 public void ToUpper1 ()
3693 string s = "OrIgInAli";
3695 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3697 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (), "#1");
3699 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3701 Assert.AreEqual ("ORIGINALI", s.ToUpper (), "#2");
3704 [Test] // ToUpper (CultureInfo)
3705 public void ToUpper2 ()
3707 string s = "OrIgInAli";
3709 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3711 Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#A1");
3712 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#A2");
3713 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#A3");
3714 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#A4");
3716 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3718 Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#B1");
3719 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#B2");
3720 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#B3");
3721 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#B4");
3724 [Test] // ToUpper (CultureInfo)
3725 public void ToUpper2_Culture_Null ()
3727 string s = "OrIgInAl";
3730 s.ToUpper ((CultureInfo) null);
3731 Assert.Fail ("#A1");
3732 } catch (ArgumentNullException ex) {
3733 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
3734 Assert.IsNull (ex.InnerException, "#A3");
3735 Assert.IsNotNull (ex.Message, "#A4");
3736 Assert.AreEqual ("culture", ex.ParamName, "#A5");
3740 string.Empty.ToUpper ((CultureInfo) null);
3741 Assert.Fail ("#B1");
3742 } catch (ArgumentNullException ex) {
3743 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
3744 Assert.IsNull (ex.InnerException, "#B3");
3745 Assert.IsNotNull (ex.Message, "#B4");
3746 Assert.AreEqual ("culture", ex.ParamName, "#B5");
3751 public void TestTrim ()
3753 string s1 = " original\t\n";
3754 Assert.AreEqual ("original", s1.Trim(), "basic trim failed");
3755 Assert.AreEqual ("original", s1.Trim(null), "basic trim failed");
3758 Assert.AreEqual ("original", s1.Trim(), "basic trim failed");
3759 Assert.AreEqual ("original", s1.Trim(null), "basic trim failed");
3762 Assert.AreEqual (string.Empty, s1.Trim(), "empty trim failed");
3763 Assert.AreEqual (string.Empty, s1.Trim(null), "empty trim failed");
3765 s1 = "aaaoriginalbbb";
3766 char[] delims = {'a', 'b'};
3767 Assert.AreEqual ("original", s1.Trim(delims), "custom trim failed");
3769 Assert.AreEqual ("original", "\u2028original\u2029".Trim (), "net_2_0 additional char#1");
3770 Assert.AreEqual ("original", "\u0085original\u1680".Trim (), "net_2_0 additional char#2");
3772 Assert.AreEqual ("", "\x9\xa\xb\xc\xd\x20\x85\xa0\x1680\x2000\x2001\x2002\x2003\x2004\x2005\x2006\x2007\x2008\x2009\x200a\x2028\x2029\x202f\x205f\x3000".Trim (), "net_4_0 changes #1");
3776 public void TestTrimEnd ()
3778 string s1 = " original\t\n";
3779 Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed");
3782 Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed");
3785 Assert.AreEqual (string.Empty, s1.TrimEnd(null), "empty TrimEnd failed");
3787 s1 = "aaaoriginalbbb";
3788 char[] delims = {'a', 'b'};
3789 Assert.AreEqual ("aaaoriginal", s1.TrimEnd(delims), "custom TrimEnd failed");
3793 public void TestTrimStart ()
3795 string s1 = " original\t\n";
3796 Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed");
3798 s1 = "original\t\n";
3799 Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed");
3802 Assert.AreEqual (string.Empty, s1.TrimStart(null), "empty TrimStart failed");
3804 s1 = "aaaoriginalbbb";
3805 char[] delims = {'a', 'b'};
3806 Assert.AreEqual ("originalbbb", s1.TrimStart(delims), "custom TrimStart failed");
3810 public void TestChars ()
3817 Assert.Fail ("#A1:" + c);
3818 } catch (IndexOutOfRangeException ex) {
3819 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
3820 Assert.IsNull (ex.InnerException, "#A3");
3821 Assert.IsNotNull (ex.Message, "#A4");
3827 Assert.Fail ("#B1:" + c);
3828 } catch (IndexOutOfRangeException ex) {
3829 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
3830 Assert.IsNull (ex.InnerException, "#B3");
3831 Assert.IsNotNull (ex.Message, "#B4");
3836 public void TestComparePeriod ()
3838 // according to bug 63981, this behavior is for all cultures
3839 Assert.AreEqual (-1, String.Compare ("foo.obj", "foobar.obj", false), "#1");
3843 public void LastIndexOfAnyBounds1 ()
3845 string mono = "Mono";
3846 char [] k = { 'M' };
3848 mono.LastIndexOfAny (k, mono.Length, 1);
3850 } catch (ArgumentOutOfRangeException ex) {
3851 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3852 Assert.IsNull (ex.InnerException, "#3");
3853 Assert.IsNotNull (ex.Message, "#4");
3854 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3859 public void TestSplit ()
3861 string s1 = "abcdefghijklm";
3862 char[] c1 = {'q', 'r'};
3863 Assert.AreEqual (s1, (s1.Split(c1))[0], "No splitters");
3865 char[] c2 = {'a', 'e', 'i', 'o', 'u'};
3866 string[] chunks = s1.Split(c2);
3867 Assert.AreEqual (string.Empty, chunks[0], "First chunk");
3868 Assert.AreEqual ("bcd", chunks[1], "Second chunk");
3869 Assert.AreEqual ("fgh", chunks[2], "Third chunk");
3870 Assert.AreEqual ("jklm", chunks[3], "Fourth chunk");
3873 bool errorThrown = false;
3875 chunks = s1.Split(c2, -1);
3876 } catch (ArgumentOutOfRangeException) {
3879 Assert.IsTrue (errorThrown, "Split out of range");
3882 chunks = s1.Split(c2, 2);
3883 Assert.AreEqual (2, chunks.Length, "Limited chunk");
3884 Assert.AreEqual (string.Empty, chunks[0], "First limited chunk");
3885 Assert.AreEqual ("bcdefghijklm", chunks[1], "Second limited chunk");
3889 chunks = s3.Split(c3,2);
3890 Assert.AreEqual (2, chunks.Length, "1.0 split length");
3891 Assert.AreEqual ("1", chunks[0], "1.0 split first chunk");
3892 Assert.AreEqual ("0", chunks[1], "1.0 split second chunk");
3894 string s4 = "1.0.0";
3896 chunks = s4.Split(c4,2);
3897 Assert.AreEqual (2, chunks.Length, "1.0.0 split length");
3898 Assert.AreEqual ("1", chunks[0], "1.0.0 split first chunk");
3899 Assert.AreEqual ("0.0", chunks[1], "1.0.0 split second chunk");
3903 chunks = s5.Split (c5, 2);
3904 Assert.AreEqual (2, chunks.Length, ".0.0 split length");
3905 Assert.AreEqual (string.Empty, chunks[0], ".0.0 split first chunk");
3906 Assert.AreEqual ("0.0", chunks[1], ".0.0 split second chunk");
3910 chunks = s6.Split (c6, 2);
3911 Assert.AreEqual (2, chunks.Length, ".0 split length");
3912 Assert.AreEqual (string.Empty, chunks[0], ".0 split first chunk");
3913 Assert.AreEqual ("0", chunks[1], ".0 split second chunk");
3917 chunks = s7.Split (c7, 2);
3918 Assert.AreEqual (2, chunks.Length, "0. split length");
3919 Assert.AreEqual ("0", chunks[0], "0. split first chunk");
3920 Assert.AreEqual (string.Empty, chunks[1], "0. split second chunk");
3922 string s8 = "0.0000";
3924 chunks = s8.Split (c8, 2);
3925 Assert.AreEqual (2, chunks.Length, "0.0000/2 split length");
3926 Assert.AreEqual ("0", chunks[0], "0.0000/2 split first chunk");
3927 Assert.AreEqual ("0000", chunks[1], "0.0000/2 split second chunk");
3929 chunks = s8.Split (c8, 3);
3930 Assert.AreEqual (2, chunks.Length, "0.0000/3 split length");
3931 Assert.AreEqual ("0", chunks[0], "0.0000/3 split first chunk");
3932 Assert.AreEqual ("0000", chunks[1], "0.0000/3 split second chunk");
3934 chunks = s8.Split (c8, 1);
3935 Assert.AreEqual (1, chunks.Length, "0.0000/1 split length");
3936 Assert.AreEqual ("0.0000", chunks[0], "0.0000/1 split first chunk");
3938 chunks = s1.Split(c2, 1);
3939 Assert.AreEqual (1, chunks.Length, "Single split");
3940 Assert.AreEqual (s1, chunks[0], "Single chunk");
3942 chunks = s1.Split(c2, 0);
3943 Assert.AreEqual (0, chunks.Length, "Zero split");
3945 Assert.AreEqual (0, "\x9\xa\xb\xc\xd\x20\x85\xa0\x1680\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");
3949 public void MoreSplit ()
3951 string test = "123 456 789";
3952 string [] st = test.Split ();
3953 Assert.AreEqual ("123", st [0], "#01");
3954 st = test.Split (null);
3955 Assert.AreEqual ("123", st [0], "#02");
3957 Assert.AreEqual (1, "encyclopædia".Split (new[] { "ae" }, StringSplitOptions.None).Length, "#03");
3960 [Test] // Split (Char [], StringSplitOptions)
3961 public void Split3_Options_Invalid ()
3964 "A B".Split (new Char [] { 'A' }, (StringSplitOptions) 4096);
3966 } catch (ArgumentException ex) {
3967 // Illegal enum value: 4096
3968 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3969 Assert.IsNull (ex.InnerException, "#3");
3970 Assert.IsNotNull (ex.Message, "#4");
3971 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3972 Assert.IsNull (ex.ParamName, "#6");
3976 [Test] // Split (Char [], StringSplitOptions)
3977 public void Split4_Options_Invalid ()
3980 "A B".Split (new String [] { "A" }, (StringSplitOptions) 4096);
3982 } catch (ArgumentException ex) {
3983 // Illegal enum value: 4096
3984 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3985 Assert.IsNull (ex.InnerException, "#3");
3986 Assert.IsNotNull (ex.Message, "#4");
3987 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3988 Assert.IsNull (ex.ParamName, "#6");
3992 [Test] // Split (Char [], StringSplitOptions)
3993 public void Split5_Options_Invalid ()
3996 "A B".Split (new Char [] { 'A' }, 0, (StringSplitOptions) 4096);
3998 } catch (ArgumentException ex) {
3999 // Illegal enum value: 4096
4000 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
4001 Assert.IsNull (ex.InnerException, "#3");
4002 Assert.IsNotNull (ex.Message, "#4");
4003 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
4004 Assert.IsNull (ex.ParamName, "#6");
4008 [Test] // Split (String [], Int32, StringSplitOptions)
4009 public void Split6_Count_Negative ()
4012 "A B".Split (new String [] { "A" }, -1, StringSplitOptions.None);
4014 } catch (ArgumentOutOfRangeException ex) {
4015 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
4016 Assert.IsNull (ex.InnerException, "#3");
4017 Assert.IsNotNull (ex.Message, "#4");
4018 Assert.AreEqual ("count", ex.ParamName, "#5");
4022 [Test] // Split (String [], Int32, StringSplitOptions)
4023 public void Split6_Options_Invalid ()
4026 "A B".Split (new String [] { "A" }, 0, (StringSplitOptions) 4096);
4028 } catch (ArgumentException ex) {
4029 // Illegal enum value: 4096
4030 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
4031 Assert.IsNull (ex.InnerException, "#3");
4032 Assert.IsNotNull (ex.Message, "#4");
4033 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
4034 Assert.IsNull (ex.ParamName, "#6");
4039 public void SplitString ()
4044 res = "A B C".Split (new String [] { "A" }, 0, StringSplitOptions.None);
4045 Assert.AreEqual (0, res.Length);
4047 // empty and RemoveEmpty
4048 res = string.Empty.Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries);
4049 Assert.AreEqual (0, res.Length);
4052 res = "A B C".Split (new String [] { "D" }, StringSplitOptions.None);
4053 Assert.AreEqual (1, res.Length);
4054 Assert.AreEqual ("A B C", res [0]);
4057 res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.None);
4058 Assert.AreEqual (4, res.Length);
4059 Assert.AreEqual ("A ", res [0]);
4060 Assert.AreEqual (" C ", res [1]);
4061 Assert.AreEqual (string.Empty, res [2]);
4062 Assert.AreEqual (" E", res [3]);
4064 // Same with RemoveEmptyEntries
4065 res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.RemoveEmptyEntries);
4066 Assert.AreEqual (3, res.Length);
4067 Assert.AreEqual ("A ", res [0]);
4068 Assert.AreEqual (" C ", res [1]);
4069 Assert.AreEqual (" E", res [2]);
4071 // Delimiter matches once at the beginning of the string
4072 res = "A B".Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries);
4073 Assert.AreEqual (1, res.Length);
4074 Assert.AreEqual (" B", res [0]);
4076 // Delimiter at the beginning and at the end
4077 res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.None);
4078 Assert.AreEqual (3, res.Length);
4079 Assert.AreEqual (string.Empty, res [0]);
4080 Assert.AreEqual (" C DD ", res [1]);
4081 Assert.AreEqual (string.Empty, res [2]);
4083 res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.RemoveEmptyEntries);
4084 Assert.AreEqual (1, res.Length);
4085 Assert.AreEqual (" C DD ", res [0]);
4088 res = "A B C DD E".Split (new String[] { "B", "D" }, 2, StringSplitOptions.None);
4089 Assert.AreEqual (2, res.Length);
4090 Assert.AreEqual ("A ", res [0]);
4091 Assert.AreEqual (" C DD E", res [1]);
4094 res = "ABCDEF".Split (new String[] { "EF", "BCDE" }, StringSplitOptions.None);
4095 Assert.AreEqual (2, res.Length);
4096 Assert.AreEqual ("A", res [0]);
4097 Assert.AreEqual ("F", res [1]);
4099 res = "ABCDEF".Split (new String[] { "BCD", "BC" }, StringSplitOptions.None);
4100 Assert.AreEqual (2, res.Length);
4101 Assert.AreEqual ("A", res [0]);
4102 Assert.AreEqual ("EF", res [1]);
4105 res = "A B\nC".Split ((String[])null, StringSplitOptions.None);
4106 Assert.AreEqual (3, res.Length);
4107 Assert.AreEqual ("A", res [0]);
4108 Assert.AreEqual ("B", res [1]);
4109 Assert.AreEqual ("C", res [2]);
4111 res = "A B\nC".Split (new String [0], StringSplitOptions.None);
4112 Assert.AreEqual (3, res.Length);
4113 Assert.AreEqual ("A", res [0]);
4114 Assert.AreEqual ("B", res [1]);
4115 Assert.AreEqual ("C", res [2]);
4119 public void SplitStringChars ()
4124 res = string.Empty.Split (new Char [] { 'A' });
4125 Assert.AreEqual (1, res.Length);
4126 Assert.AreEqual (string.Empty, res [0]);
4128 // empty and RemoveEmpty
4129 res = string.Empty.Split (new Char [] { 'A' }, StringSplitOptions.RemoveEmptyEntries);
4130 Assert.AreEqual (0, res.Length);
4133 res = "..A..B..".Split (new Char[] { '.' }, 0, StringSplitOptions.None);
4134 Assert.AreEqual (0, res.Length, "#01-01");
4137 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.None);
4138 Assert.AreEqual (1, res.Length, "#02-01");
4139 Assert.AreEqual ("..A..B..", res [0], "#02-02");
4141 // count == 1 + RemoveEmpty
4142 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries);
4143 Assert.AreEqual (1, res.Length, "#03-01");
4144 Assert.AreEqual ("..A..B..", res [0], "#03-02");
4146 // Strange Case A+B A
4147 res = "...".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries);
4148 Assert.AreEqual (1, res.Length, "#ABA-01");
4149 Assert.AreEqual ("...", res [0], "#ABA-02");
4151 // Strange Case A+B B
4152 res = "...".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4153 Assert.AreEqual (0, res.Length, "#ABB-01");
4155 // Keeping Empties and multipe split chars
4156 res = "..A;.B.;".Split (new Char[] { '.', ';' }, StringSplitOptions.None);
4157 Assert.AreEqual (7, res.Length, "#04-01");
4158 Assert.AreEqual (string.Empty, res [0], "#04-02");
4159 Assert.AreEqual (string.Empty, res [1], "#04-03");
4160 Assert.AreEqual ("A", res [2], "#04-04");
4161 Assert.AreEqual (string.Empty, res [3], "#04-05");
4162 Assert.AreEqual ("B", res [4], "#04-06");
4163 Assert.AreEqual (string.Empty, res [5], "#04-07");
4164 Assert.AreEqual (string.Empty, res [6], "#04-08");
4166 // Trimming (3 tests)
4167 res = "..A".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4168 Assert.AreEqual (1, res.Length, "#05-01");
4169 Assert.AreEqual ("A", res [0], "#05-02");
4171 res = "A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4172 Assert.AreEqual (1, res.Length, "#06-01");
4173 Assert.AreEqual ("A", res [0], "#06-02");
4175 res = "..A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4176 Assert.AreEqual (1, res.Length, "#07-01");
4177 Assert.AreEqual ("A", res [0], "#07-02");
4180 res = "..A..B..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4181 Assert.AreEqual (2, res.Length, "#08-01");
4182 Assert.AreEqual ("A", res [0], "#08-02");
4183 Assert.AreEqual ("B..", res [1], "#08-03");
4185 // Whitespace and Long split chain (removing empty chars)
4186 res = " A\tBC\n\rDEF GHI ".Split ((Char[])null, StringSplitOptions.RemoveEmptyEntries);
4187 Assert.AreEqual (4, res.Length, "#09-01");
4188 Assert.AreEqual ("A", res [0], "#09-02");
4189 Assert.AreEqual ("BC", res [1], "#09-03");
4190 Assert.AreEqual ("DEF", res [2], "#09-04");
4191 Assert.AreEqual ("GHI", res [3], "#09-05");
4193 // Nothing but separators
4194 res = "..,.;.,".Split (new Char[]{'.',',',';'},2,StringSplitOptions.RemoveEmptyEntries);
4195 Assert.AreEqual (0, res.Length, "#10-01");
4197 // Complete testseries
4198 char[] dash = new Char[] { '/' };
4199 StringSplitOptions o = StringSplitOptions.RemoveEmptyEntries;
4200 Assert.AreEqual ("hi", "hi".Split (dash, o)[0], "#11-01");
4201 Assert.AreEqual ("hi", "hi/".Split (dash, o)[0], "#11-02");
4202 Assert.AreEqual ("hi", "/hi".Split (dash, o)[0], "#11-03");
4204 Assert.AreEqual ("hi..", "hi../".Split (dash, o)[0], "#11-04-1");
4205 Assert.AreEqual ("hi..", "/hi..".Split (dash, o)[0], "#11-04-2");
4207 res = "/hi/..".Split (dash, o);
4208 Assert.AreEqual ("hi", res[0], "#11-05-1");
4209 Assert.AreEqual ("..", res[1], "#11-05-2");
4210 Assert.AreEqual (2, res.Length, "#11-09-3");
4212 res = "hi/..".Split (dash, o);
4213 Assert.AreEqual ("hi", res[0], "#11-06-1");
4214 Assert.AreEqual ("..", res[1], "#11-06-2");
4215 Assert.AreEqual (2, res.Length, "#11-09-3");
4217 res = "hi/../".Split (dash, o);
4218 Assert.AreEqual ("hi", res[0], "#11-07-1");
4219 Assert.AreEqual ("..", res[1], "#11-07-2");
4220 Assert.AreEqual (2, res.Length, "#11-07-3");
4222 res = "/hi../".Split (dash, o);
4223 Assert.AreEqual ("hi..", res[0], "#11-08-1");
4224 Assert.AreEqual (1, res.Length, "#11-08-2");
4226 res = "/hi/../".Split (dash, o);
4227 Assert.AreEqual ("hi", res[0], "#11-09-1");
4228 Assert.AreEqual ("..", res[1], "#11-09-2");
4229 Assert.AreEqual (2, res.Length, "#11-09-3");
4231 Assert.AreEqual (0, " ".Split ((char[]) null, 2, StringSplitOptions.RemoveEmptyEntries).Length, "#12-00-0");
4233 res = "not found".Split (new char[2]);
4234 Assert.AreEqual ("not found", res[0], "#12-04-27");
4235 Assert.AreEqual (1, res.Length, "#12-04-27-A");
4239 public void SplitStringStrings ()
4244 res = "..A..B..".Split (new String[] { "." }, 0, StringSplitOptions.None);
4245 Assert.AreEqual (0, res.Length, "#01-01");
4248 res = "..A..B..".Split (new String[] { "." }, 1, StringSplitOptions.None);
4249 Assert.AreEqual (1, res.Length, "#02-01");
4250 Assert.AreEqual ("..A..B..", res [0], "#02-02");
4252 // count == 1 + RemoveEmpty
4253 res = "..A..B..".Split (new String[] { "." }, 1, StringSplitOptions.RemoveEmptyEntries);
4254 Assert.AreEqual (1, res.Length, "#03-01");
4255 Assert.AreEqual ("..A..B..", res [0], "#03-02");
4257 // Strange Case A+B A
4258 res = "...".Split (new String[] { "." }, 1, StringSplitOptions.RemoveEmptyEntries);
4259 Assert.AreEqual (1, res.Length, "#ABA-01");
4260 Assert.AreEqual ("...", res [0], "#ABA-02");
4262 // Strange Case A+B B
4263 res = "...".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4264 Assert.AreEqual (0, res.Length, "#ABB-01");
4266 // Keeping Empties and multipe split chars
4267 res = "..A;.B.;".Split (new String[] { ".", ";" }, StringSplitOptions.None);
4268 Assert.AreEqual (7, res.Length, "#04-01");
4269 Assert.AreEqual (string.Empty, res [0], "#04-02");
4270 Assert.AreEqual (string.Empty, res [1], "#04-03");
4271 Assert.AreEqual ("A", res [2], "#04-04");
4272 Assert.AreEqual (string.Empty, res [3], "#04-05");
4273 Assert.AreEqual ("B", res [4], "#04-06");
4274 Assert.AreEqual (string.Empty, res [5], "#04-07");
4275 Assert.AreEqual (string.Empty, res [6], "#04-08");
4277 // Trimming (3 tests)
4278 res = "..A".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4279 Assert.AreEqual (1, res.Length, "#05-01");
4280 Assert.AreEqual ("A", res [0], "#05-02");
4282 res = "A..".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4283 Assert.AreEqual (1, res.Length, "#06-01");
4284 Assert.AreEqual ("A", res [0], "#06-02");
4286 res = "..A..".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4287 Assert.AreEqual (1, res.Length, "#07-01");
4288 Assert.AreEqual ("A", res [0], "#07-02");
4291 res = "..A..B..".Split (new String[] { "." }, 2, StringSplitOptions.RemoveEmptyEntries);
4292 Assert.AreEqual (2, res.Length, "#08-01");
4293 Assert.AreEqual ("A", res [0], "#08-02");
4294 Assert.AreEqual ("B..", res [1], "#08-03");
4296 // Whitespace and Long split chain (removing empty chars)
4297 res = " A\tBC\n\rDEF GHI ".Split ((String[])null, StringSplitOptions.RemoveEmptyEntries);
4298 Assert.AreEqual (4, res.Length, "#09-01");
4299 Assert.AreEqual ("A", res [0], "#09-02");
4300 Assert.AreEqual ("BC", res [1], "#09-03");
4301 Assert.AreEqual ("DEF", res [2], "#09-04");
4302 Assert.AreEqual ("GHI", res [3], "#09-05");
4304 // Nothing but separators
4305 res = "..,.;.,".Split (new String[]{".",",",";"},2,StringSplitOptions.RemoveEmptyEntries);
4306 Assert.AreEqual (0, res.Length, "#10-01");
4308 // Complete testseries
4309 String[] dash = new String[] { "/" };
4310 StringSplitOptions o = StringSplitOptions.RemoveEmptyEntries;
4311 Assert.AreEqual ("hi", "hi".Split (dash, o)[0], "#11-01");
4312 Assert.AreEqual ("hi", "hi/".Split (dash, o)[0], "#11-02");
4313 Assert.AreEqual ("hi", "/hi".Split (dash, o)[0], "#11-03");
4315 Assert.AreEqual ("hi..", "hi../".Split (dash, o)[0], "#11-04-1");
4316 Assert.AreEqual ("hi..", "/hi..".Split (dash, o)[0], "#11-04-2");
4318 res = "/hi/..".Split (dash, o);
4319 Assert.AreEqual ("hi", res[0], "#11-05-1");
4320 Assert.AreEqual ("..", res[1], "#11-05-2");
4321 Assert.AreEqual (2, res.Length, "#11-09-3");
4323 res = "hi/..".Split (dash, o);
4324 Assert.AreEqual ("hi", res[0], "#11-06-1");
4325 Assert.AreEqual ("..", res[1], "#11-06-2");
4326 Assert.AreEqual (2, res.Length, "#11-09-3");
4328 res = "hi/../".Split (dash, o);
4329 Assert.AreEqual ("hi", res[0], "#11-07-1");
4330 Assert.AreEqual ("..", res[1], "#11-07-2");
4331 Assert.AreEqual (2, res.Length, "#11-07-3");
4333 res = "/hi../".Split (dash, o);
4334 Assert.AreEqual ("hi..", res[0], "#11-08-1");
4335 Assert.AreEqual (1, res.Length, "#11-08-2");
4337 res = "/hi/../".Split (dash, o);
4338 Assert.AreEqual ("hi", res[0], "#11-09-1");
4339 Assert.AreEqual ("..", res[1], "#11-09-2");
4340 Assert.AreEqual (2, res.Length, "#11-09-3");
4344 [Category ("NotDotNet")]
4345 public void Normalize1 ()
4347 // .NET does not combine them into U+1F80
4348 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u03B1\u0313\u0345
4349 string s = "\u03B1\u0313\u0345";
4350 Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormC), "#1");
4351 Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormKC), "#2");
4352 Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormC), "#3");
4353 Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormKC), "#4");
4357 [Category ("NotDotNet")]
4358 public void Normalize2 ()
4360 string s1 = "\u0061\u0301bc";
4361 string s2 = "\u00e1bc";
4362 // .NET does not combine \u0061\0301 into \u00E1
4363 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u0061\u0301bc
4364 Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormC), "#1");
4365 Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormKC), "#2");
4369 public void Normalize3 ()
4371 var s = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0654', '\u0652', '\u064A', '\u064F', '\u0648', '\u0654' });
4373 var formC = new string (new char [] { '\u064A', '\u064F', '\u0624', '\u0652', '\u064a', '\u064f', '\u0624' });
4374 var formD = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0652', '\u0654', '\u064a', '\u064f', '\u0648', '\u0654' });
4375 var formKC = new string (new char [] { '\u064A', '\u064F', '\u0624', '\u0652', '\u064a', '\u064f', '\u0624' });
4376 var formKD = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0652', '\u0654', '\u064a', '\u064f', '\u0648', '\u0654' });
4378 Assert.AreEqual (formD, s.Normalize (NormalizationForm.FormD), "#1");
4379 Assert.AreEqual (formC, s.Normalize (NormalizationForm.FormC), "#2");
4380 Assert.AreEqual (formKD, s.Normalize (NormalizationForm.FormKD), "#3");
4381 Assert.AreEqual (formKC, s.Normalize (NormalizationForm.FormKC), "#4");
4384 [Test] // bug #480152, test cases by David Mitchell
4385 public void NormalizeFormD ()
4387 Assert.AreEqual ("\u212B".Normalize (NormalizationForm.FormD), "\u0041\u030A", "#1");
4388 Assert.AreEqual ("\u1E69".Normalize (NormalizationForm.FormD), "\u0073\u0323\u0307", "#2");
4389 Assert.AreEqual ("\u1e4e".Normalize (NormalizationForm.FormD), "\u004f\u0303\u0308", "#3");
4390 Assert.AreEqual ("\u1e2f".Normalize (NormalizationForm.FormD), "\u0069\u0308\u0301", "#4");
4393 [Test] // bug #480152, test cases by David Mitchell
4394 public void NormalizeFormC ()
4396 Assert.AreEqual ("\u0041\u030a\u0061\u030a".Normalize (NormalizationForm.FormC), "\u00c5\u00e5", "#1");
4397 Assert.AreEqual ("\u006E\u0303".Normalize (NormalizationForm.FormC), "\u00F1", "#2");
4398 Assert.AreEqual ("\u03B7\u0313\u0300\u0345".Normalize (NormalizationForm.FormC), "\u1F92", "#3");
4401 [Test] // bug #480152, test cases by Tom Philpot
4402 public void NormalizeFormCCrashers ()
4404 string[][] entries = new string[][] {
4405 new string[] { "\u05d0\u0307\u05dc", "#1" },
4406 new string[] { "\u05d0\u0307\u05dc\u05d9\u05d9\u05df", "#2" },
4407 new string[] { "\u05d4\u05d0\u0307\u05dc\u0307\u05d9\u0307\u05df\u0307", "#3" },
4408 new string[] { "\u05d9\u05e9\u05de\u05e2\u0307\u05d0\u0307\u05dc\u0307", "#4" },
4409 new string[] { "\u05d9\u05e9\u05e8\u05d0\u0307\u05dc\u0307", "#5" },
4412 foreach (string[] entry in entries)
4413 entry [0].Normalize (NormalizationForm.FormC);
4417 public void NormalizeFormCHangul ()
4419 Assert.AreEqual ("\u1100\u116C".Normalize (NormalizationForm.FormC), "\uAD34", "#1");
4420 Assert.AreEqual ("\u1100\u116B\u11C2".Normalize (NormalizationForm.FormC), "\uAD33", "#2");
4421 Assert.AreEqual ("\u1100!".Normalize (NormalizationForm.FormC), "\u1100!", "#3");
4422 Assert.AreEqual ("\u1100\u116B!".Normalize (NormalizationForm.FormC), "\uAD18\u0021", "#4");
4423 Assert.AreEqual ("!\u116C".Normalize (NormalizationForm.FormC), "!\u116C", "#5");
4424 Assert.AreEqual ("!\u116B\u11C2".Normalize (NormalizationForm.FormC), "!\u116B\u11C2", "#6");
4428 public void MoreNormalizeFormC ()
4430 Assert.AreEqual ("\u1E0A\u0323".Normalize (NormalizationForm.FormC), "\u1E0C\u0307", "#1");
4431 Assert.AreEqual ("\u0044\u0323\u0307".Normalize (NormalizationForm.FormC), "\u1E0C\u0307", "#2");
4435 public void Emptiness ()
4437 // note: entries using AreEqual are in reality AreNotSame on MS FX
4438 // but I prefer Mono implementation ;-) and it minimize the changes
4439 Assert.AreSame (String.Empty, "", "Empty");
4441 Assert.AreSame (String.Empty, String.Concat ((object) null), "Concat(null)");
4442 Assert.AreSame (String.Empty, String.Concat ((object) String.Empty), "Concat(empty)");
4443 Assert.AreSame (String.Empty, String.Concat ((object) String.Empty, (object) String.Empty), "Concat(object,object)");
4444 Assert.AreSame (String.Empty, String.Concat (String.Empty, String.Empty), "Concat(string,string)");
4445 Assert.AreEqual (String.Empty, String.Concat (String.Empty, String.Empty, String.Empty), "Concat(string,string,string)");
4446 Assert.AreEqual (String.Empty, String.Concat ((object) null, (object) (object) null, (object) null, (object) null), "Concat(null,null,null,null)-object");
4447 Assert.AreSame (String.Empty, String.Concat ((string) null, (string) (string) null, (string) null, (string) null), "Concat(null,null,null,null)-string");
4448 Assert.AreNotSame (String.Empty, String.Concat (String.Empty, String.Empty, String.Empty, String.Empty), "Concat(string,string,string,string)");
4449 Assert.AreEqual (String.Empty, String.Concat (new object [] { String.Empty, String.Empty }), "Concat(object[])");
4450 Assert.AreEqual (String.Empty, String.Concat (new string [] { String.Empty, String.Empty }), "Concat(string[])");
4452 Assert.AreNotSame (String.Empty, String.Copy (String.Empty), "Copy");
4454 Assert.AreEqual (String.Empty, "".Insert (0, String.Empty), "Insert(Empty)");
4455 Assert.AreEqual (String.Empty, String.Empty.Insert (0, ""), "Empty.Insert");
4457 Assert.AreSame (String.Empty, String.Empty.PadLeft (0), "PadLeft(int)");
4458 Assert.AreSame (String.Empty, String.Empty.PadLeft (0, '.'), "PadLeft(int.char)");
4459 Assert.AreSame (String.Empty, String.Empty.PadRight (0), "PadRight(int)");
4460 Assert.AreSame (String.Empty, String.Empty.PadRight (0, '.'), "PadRight(int.char)");
4462 Assert.AreSame (String.Empty, "".Substring (0), "Substring(int)");
4463 Assert.AreSame (String.Empty, "ab".Substring (1, 0), "Substring(int,int)");
4465 Assert.AreSame (String.Empty, "".ToLower (), "ToLower");
4466 Assert.AreSame (String.Empty, "".ToUpper (), "ToUpper");
4467 Assert.AreSame (String.Empty, "".ToLower (CultureInfo.CurrentCulture), "ToLower(CultureInfo)");
4468 Assert.AreSame (String.Empty, "".ToUpper (CultureInfo.CurrentCulture), "ToUpper(CultureInfo)");
4469 Assert.AreSame (String.Empty, "".ToLowerInvariant (), "ToLowerInvariant");
4470 Assert.AreSame (String.Empty, "".ToUpperInvariant (), "ToUpperInvariant");
4472 Assert.AreSame (String.Empty, "".Trim (), "Trim()");
4473 Assert.AreSame (String.Empty, "a".Trim ('a'), "Trim(char)");
4474 Assert.AreSame (String.Empty, "a".TrimEnd ('a'), "TrimEnd(char)");
4475 Assert.AreSame (String.Empty, "a".TrimStart ('a'), "TrimStart(char)");
4479 public void LastIndexOfAndEmptiness () {
4480 Assert.AreEqual (-1, "".LastIndexOf('.'), "#1");
4481 Assert.AreEqual (-1, "".LastIndexOf('.', -1), "#2");
4482 Assert.AreEqual (-1, "".LastIndexOf('.', -1, -1), "#3");
4483 Assert.AreEqual (0, "x".LastIndexOf('x', 0), "#4");
4484 Assert.AreEqual (0 , "x".LastIndexOf('x', 0, 1), "#5");
4485 Assert.AreEqual (-1 , "x".LastIndexOf('z', 0, 1), "#6");
4488 "".LastIndexOf(null);
4490 } catch (ArgumentNullException) {}
4492 Assert.AreEqual (0, "".LastIndexOf(""), "#8");
4493 Assert.AreEqual (0, "".LastIndexOf("", -1), "#9");
4494 Assert.AreEqual (0, "".LastIndexOf("", -1, 1), "#10");
4495 Assert.AreEqual (0, "".LastIndexOf("", StringComparison.Ordinal), "#11");
4496 Assert.AreEqual (0, "".LastIndexOf("", -1, StringComparison.Ordinal), "#12");
4497 Assert.AreEqual (0, "".LastIndexOf("", -1, -1, StringComparison.Ordinal), "#13");
4498 Assert.AreEqual (0, "x".LastIndexOf(""), "#14");
4500 Assert.AreEqual (0, "x".LastIndexOf("x", 0), "#15");
4501 Assert.AreEqual (0, "x".LastIndexOf("", 0), "#16");
4502 Assert.AreEqual (0, "xxxx".LastIndexOf("", 0), "#17");
4503 Assert.AreEqual (1, "xxxx".LastIndexOf("", 1), "#18");
4505 Assert.AreEqual (1, "xy".LastIndexOf(""), "#19");
4506 Assert.AreEqual (2, "xyz".LastIndexOf(""), "#20");
4507 Assert.AreEqual (1, "xy".LastIndexOf(""), "#21");
4508 Assert.AreEqual (1, "xy".LastIndexOf("", 2), "#22");
4509 Assert.AreEqual (2, "xyz".LastIndexOf("", 2), "#23");
4510 Assert.AreEqual (2, "xyz".LastIndexOf("", 2, 2), "#24");
4511 Assert.AreEqual (2, "xyz".LastIndexOf("", 3, 3), "#25");
4514 "xy".LastIndexOf("", 29);
4515 Assert.Fail ("#26");
4516 }catch (ArgumentOutOfRangeException){}
4518 Assert.AreEqual (-1, "".LastIndexOf("x"), "#27");
4519 Assert.AreEqual (-1, "".LastIndexOf("x", -1), "#28");
4520 Assert.AreEqual (-1, "".LastIndexOf("x", -1), "#29");
4521 Assert.AreEqual (-1, "".LastIndexOf("x", StringComparison.Ordinal), "#30");
4522 Assert.AreEqual (-1, "".LastIndexOf("x", -1, StringComparison.Ordinal), "#31");
4523 Assert.AreEqual (-1, "".LastIndexOf("x", -1, -1, StringComparison.Ordinal), "#32");
4525 Assert.AreEqual (1, "xx".LastIndexOf("", StringComparison.Ordinal), "#33");
4526 Assert.AreEqual (1, "xx".LastIndexOf("", 2, StringComparison.Ordinal), "#34");
4527 Assert.AreEqual (1, "xx".LastIndexOf("", 2, 2, StringComparison.Ordinal), "#35");
4529 Assert.AreEqual (3, "xxxx".LastIndexOf("", StringComparison.Ordinal), "#36");
4530 Assert.AreEqual (2, "xxxx".LastIndexOf("", 2, StringComparison.Ordinal), "#37");
4531 Assert.AreEqual (2, "xxxx".LastIndexOf("", 2, 2, StringComparison.Ordinal), "#38");
4533 Assert.AreEqual (3, "xxxx".LastIndexOf("", 3, StringComparison.Ordinal), "#39");
4534 Assert.AreEqual (3, "xxxx".LastIndexOf("", 3, 3, StringComparison.Ordinal), "#40");
4539 public void LastIndexOfAnyAndEmptiness () {
4540 Assert.AreEqual (-1, "".LastIndexOfAny(new char[] {'.', 'x'}), "#1");
4541 Assert.AreEqual (-1, "".LastIndexOfAny(new char[] {'.', 'x'}, -1), "#2");
4542 Assert.AreEqual (-1, "".LastIndexOfAny(new char[] {'.', 'x'}, -1, -1), "#3");