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 private CultureInfo orgCulture;
32 // save current culture
33 orgCulture = CultureInfo.CurrentCulture;
37 public void TearDown ()
39 // restore original culture
40 Thread.CurrentThread.CurrentCulture = orgCulture;
45 [Test] // ctor (Char [])
46 public unsafe void Constructor2 ()
48 Assert.AreEqual (String.Empty, new String ((char[]) null), "#1");
49 Assert.AreEqual (String.Empty, new String (new Char [0]), "#2");
50 Assert.AreEqual ("A", new String (new Char [1] {'A'}), "#3");
54 [Test] // ctor (Char, Int32)
55 public void Constructor4 ()
57 Assert.AreEqual (string.Empty, new String ('A', 0));
58 Assert.AreEqual (new String ('A', 3), "AAA");
61 [Test] // ctor (Char, Int32)
62 public void Constructor4_Count_Negative ()
67 } catch (ArgumentOutOfRangeException ex) {
68 // 'count' must be non-negative
69 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
70 Assert.IsNull (ex.InnerException, "#3");
71 Assert.IsNotNull (ex.Message, "#4");
72 Assert.AreEqual ("count", ex.ParamName, "#5");
76 [Test] // ctor (Char [], Int32, Int32)
77 public void Constructor6 ()
79 char [] arr = new char [3] { 'A', 'B', 'C' };
80 Assert.AreEqual ("ABC", new String (arr, 0, arr.Length), "#1");
81 Assert.AreEqual ("BC", new String (arr, 1, 2), "#2");
82 Assert.AreEqual (string.Empty, new String (arr, 2, 0), "#3");
85 [Test] // ctor (Char [], Int32, Int32)
86 public void Constructor6_Length_Negative ()
88 char [] arr = new char [3] { 'A', 'B', 'C' };
91 new String (arr, 0, -1);
93 } catch (ArgumentOutOfRangeException ex) {
94 // Length cannot be less than zero
95 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
96 Assert.IsNull (ex.InnerException, "#3");
97 Assert.IsNotNull (ex.Message, "#4");
98 Assert.AreEqual ("length", ex.ParamName, "#5");
102 [Test] // ctor (Char [], Int32, Int32)
103 public void Constructor6_Length_Overflow ()
105 char [] arr = new char [3] { 'A', 'B', 'C' };
108 new String (arr, 1, 3);
110 } catch (ArgumentOutOfRangeException ex) {
111 // Index was out of range. Must be non-negative and
112 // less than the size of the collection
113 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
114 Assert.IsNull (ex.InnerException, "#3");
115 Assert.IsNotNull (ex.Message, "#4");
116 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
120 [Test] // ctor (Char [], Int32, Int32)
121 public void Constructor6_StartIndex_Negative ()
123 char [] arr = new char [3] { 'A', 'B', 'C' };
126 new String (arr, -1, 0);
128 } catch (ArgumentOutOfRangeException ex) {
129 // StartIndex cannot be less than zero
130 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
131 Assert.IsNull (ex.InnerException, "#3");
132 Assert.IsNotNull (ex.Message, "#4");
133 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
137 [Test] // ctor (Char [], Int32, Int32)
138 public void Constructor6_Value_Null ()
141 new String ((char []) null, 0, 0);
143 } catch (ArgumentNullException ex) {
144 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
145 Assert.IsNull (ex.InnerException, "#3");
146 Assert.IsNotNull (ex.Message, "#4");
147 Assert.AreEqual ("value", ex.ParamName, "#5");
153 public unsafe void CharPtrConstructor ()
155 Assert.AreEqual (String.Empty, new String ((char*) null), "char*");
156 Assert.AreEqual (String.Empty, new String ((char*) null, 0, 0), "char*,int,int");
160 public unsafe void TestSbytePtrConstructorASCII ()
162 Encoding encoding = Encoding.ASCII;
163 String s = "ASCII*\0";
164 byte[] bytes = encoding.GetBytes (s);
166 fixed (byte* bytePtr = bytes)
167 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding));
171 public unsafe void TestSbytePtrConstructorDefault ()
173 Encoding encoding = Encoding.Default;
174 byte [] bytes = new byte [256];
176 for (int i = 0; i < 255; i++)
177 bytes [i] = (byte) (i + 1);
178 bytes [255] = (byte) 0;
180 // Ensure that bytes are valid for Encoding.Default
181 bytes = encoding.GetBytes (encoding.GetChars (bytes));
182 String s = encoding.GetString(bytes);
184 // Ensure null terminated array
185 bytes [bytes.Length - 1] = (byte) 0;
187 fixed (byte* bytePtr = bytes)
189 Assert.AreEqual (s.Substring (0, s.Length - 1), new String ((sbyte*) bytePtr));
190 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length));
191 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, null));
192 Assert.AreEqual (s, new String ((sbyte*) bytePtr, 0, bytes.Length, encoding));
196 [Test] // ctor (SByte*)
197 public unsafe void Constructor3_Value_Null ()
199 Assert.AreEqual (String.Empty, new String ((sbyte*) null));
202 [Test] // ctor (SByte*)
203 public unsafe void Constructor3_Value_Invalid ()
206 new String ((sbyte*) (-1));
208 } catch (ArgumentOutOfRangeException ex) {
209 // Pointer startIndex and length do not refer to a
211 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
212 Assert.IsNull (ex.InnerException, "#3");
213 Assert.IsNotNull (ex.Message, "#4");
214 Assert.AreEqual ("ptr", ex.ParamName, "#5");
218 [Test] // ctor (SByte*, Int32, Int32)
219 public unsafe void Constructor7_Length_Negative ()
222 new String ((sbyte*) null, 0, -1);
224 } catch (ArgumentOutOfRangeException ex) {
225 // Length cannot be less than zero
226 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
227 Assert.IsNull (ex.InnerException, "#3");
228 Assert.IsNotNull (ex.Message, "#4");
229 Assert.AreEqual ("length", ex.ParamName, "#5");
233 [Test] // ctor (SByte*, Int32, Int32)
234 public unsafe void Constructor7_StartIndex_Negative ()
237 new String ((sbyte*) null, -1, 0);
239 } catch (ArgumentOutOfRangeException ex) {
240 // StartIndex cannot be less than zero
241 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
242 Assert.IsNull (ex.InnerException, "#3");
243 Assert.IsNotNull (ex.Message, "#4");
244 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
249 public unsafe void Constructor7_StartIndex_Overflow ()
252 new String ((sbyte*) (-1), 1, 0);
254 } catch (ArgumentOutOfRangeException ex) {
255 // Pointer startIndex and length do not refer to a
257 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
258 Assert.IsNull (ex.InnerException, "#A3");
259 Assert.IsNotNull (ex.Message, "#A4");
260 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
264 new String ((sbyte*) (-1), 1, 1);
266 } catch (ArgumentOutOfRangeException ex) {
267 // Pointer startIndex and length do not refer to a
269 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
270 Assert.IsNull (ex.InnerException, "#B3");
271 Assert.IsNotNull (ex.Message, "#B4");
272 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
276 [Test] // ctor (SByte*, Int32, Int32)
277 public unsafe void Constructor7_Value_Invalid ()
280 new String ((sbyte*) (-1), 0, 1);
282 } catch (ArgumentOutOfRangeException ex) {
283 // Pointer startIndex and length do not refer to a
285 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
286 Assert.IsNull (ex.InnerException, "#3");
287 Assert.IsNotNull (ex.Message, "#4");
288 Assert.AreEqual ("ptr", ex.ParamName, "#5");
292 [Test] // ctor (SByte*, Int32, Int32)
293 public unsafe void Constructor7_Value_Null ()
297 new String ((sbyte*) null, 0, 0);
299 } catch (ArgumentNullException ex) {
300 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
301 Assert.IsNull (ex.InnerException, "#A3");
302 Assert.IsNotNull (ex.Message, "#A4");
303 Assert.AreEqual ("value", ex.ParamName, "#A5");
306 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0), "#A");
311 new String ((sbyte*) null, 0, 1);
313 } catch (ArgumentNullException ex) {
314 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
315 Assert.IsNull (ex.InnerException, "#B3");
316 Assert.IsNotNull (ex.Message, "#B4");
317 Assert.AreEqual ("value", ex.ParamName, "#B5");
320 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 1), "#B");
325 new String ((sbyte*) null, 1, 0);
327 } catch (ArgumentNullException ex) {
328 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
329 Assert.IsNull (ex.InnerException, "#C3");
330 Assert.IsNotNull (ex.Message, "#C4");
331 Assert.AreEqual ("value", ex.ParamName, "#C5");
334 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0), "#C");
338 [Test] // ctor (SByte*, Int32, Int32, Encoding)
339 public unsafe void Constructor8_Length_Negative ()
342 new String ((sbyte*) null, 0, -1, null);
344 } catch (ArgumentOutOfRangeException ex) {
345 // Length cannot be less than zero
346 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
347 Assert.IsNull (ex.InnerException, "#A3");
348 Assert.IsNotNull (ex.Message, "#A4");
349 Assert.AreEqual ("length", ex.ParamName, "#A5");
353 new String ((sbyte*) null, 0, -1, Encoding.Default);
355 } catch (ArgumentOutOfRangeException ex) {
356 // Non-negative number required
357 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
358 Assert.IsNull (ex.InnerException, "#B3");
359 Assert.IsNotNull (ex.Message, "#B4");
360 Assert.AreEqual ("length", ex.ParamName, "#B5");
364 [Test] // ctor (SByte*, Int32, Int32, Encoding)
365 public unsafe void Constructor8_StartIndex_Negative ()
368 new String ((sbyte*) null, -1, 0, null);
370 } catch (ArgumentOutOfRangeException ex) {
371 // StartIndex cannot be less than zero
372 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
373 Assert.IsNull (ex.InnerException, "#A3");
374 Assert.IsNotNull (ex.Message, "#A4");
375 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
379 new String ((sbyte*) null, -1, 0, Encoding.Default);
381 } catch (ArgumentOutOfRangeException ex) {
382 // StartIndex cannot be less than zero
383 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
384 Assert.IsNull (ex.InnerException, "#B3");
385 Assert.IsNotNull (ex.Message, "#B4");
386 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
391 public unsafe void Constructor8_StartIndex_Overflow ()
394 new String ((sbyte*) (-1), 1, 0, null);
396 } catch (ArgumentOutOfRangeException ex) {
397 // Pointer startIndex and length do not refer to a
399 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
400 Assert.IsNull (ex.InnerException, "#A3");
401 Assert.IsNotNull (ex.Message, "#A4");
402 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
406 new String ((sbyte*) (-1), 1, 1, null);
408 } catch (ArgumentOutOfRangeException ex) {
409 // Pointer startIndex and length do not refer to a
411 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
412 Assert.IsNull (ex.InnerException, "#B3");
413 Assert.IsNotNull (ex.Message, "#B4");
414 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
418 new String ((sbyte*) (-1), 1, 0, Encoding.Default);
420 } catch (ArgumentOutOfRangeException ex) {
421 // Pointer startIndex and length do not refer to a
423 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
424 Assert.IsNull (ex.InnerException, "#C3");
425 Assert.IsNotNull (ex.Message, "#C4");
426 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
430 new String ((sbyte*) (-1), 1, 1, Encoding.Default);
432 } catch (ArgumentOutOfRangeException ex) {
433 // Pointer startIndex and length do not refer to a
435 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
436 Assert.IsNull (ex.InnerException, "#D3");
437 Assert.IsNotNull (ex.Message, "#D4");
438 Assert.AreEqual ("startIndex", ex.ParamName, "#D5");
442 [Test] // ctor (SByte*, Int32, Int32, Encoding)
443 public unsafe void Constructor8_Value_Invalid ()
446 new String ((sbyte*) (-1), 0, 1, null);
448 } catch (ArgumentOutOfRangeException ex) {
449 // Pointer startIndex and length do not refer to a
451 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
452 Assert.IsNull (ex.InnerException, "#3");
453 Assert.IsNotNull (ex.Message, "#4");
454 Assert.AreEqual ("ptr", ex.ParamName, "#5");
460 [Ignore ("Runtime throws NullReferenceException instead of AccessViolationException")]
461 [ExpectedException (typeof (AccessViolationException))]
463 [ExpectedException (typeof (NullReferenceException))]
465 public unsafe void Constructor8_Value_Invalid2 ()
467 new String ((sbyte*) (-1), 0, 1, Encoding.Default);
470 [Test] // ctor (SByte*, Int32, Int32, Encoding)
471 public unsafe void Constructor8_Value_Null ()
475 new String ((sbyte*) null, 0, 0, null);
477 } catch (ArgumentNullException ex) {
478 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
479 Assert.IsNull (ex.InnerException, "#A3");
480 Assert.IsNotNull (ex.Message, "#A4");
481 Assert.AreEqual ("value", ex.ParamName, "#A5");
484 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0, null), "#A");
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");
498 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 1, null), "#B");
503 new String ((sbyte*) null, 1, 0, null);
505 } catch (ArgumentNullException ex) {
506 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
507 Assert.IsNull (ex.InnerException, "#C3");
508 Assert.IsNotNull (ex.Message, "#C4");
509 Assert.AreEqual ("value", ex.ParamName, "#C5");
512 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0, null), "#C");
515 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 0, 0, Encoding.Default), "#D");
518 new String ((sbyte*) null, 0, 1, Encoding.Default);
521 } catch (ArgumentOutOfRangeException ex) {
522 // Pointer startIndex and length do not refer to a
524 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2");
525 Assert.IsNull (ex.InnerException, "#E3");
526 Assert.IsNotNull (ex.Message, "#E4");
527 //Assert.AreEqual ("value", ex.ParamName, "#E5");
530 } catch (NullReferenceException ex) {
531 Assert.AreEqual (typeof (NullReferenceException), ex.GetType (), "#E2");
532 Assert.IsNull (ex.InnerException, "#E3");
533 Assert.IsNotNull (ex.Message, "#E4");
537 Assert.AreEqual (String.Empty, new String ((sbyte*) null, 1, 0, Encoding.Default), "#F");
542 public void Length ()
544 string str = "test string";
546 Assert.AreEqual (11, str.Length, "wrong length");
552 string s1 = "oRiGiNal";
553 Assert.AreEqual (s1, s1.Clone (), "#A1");
554 Assert.AreSame (s1, s1.Clone (), "#A2");
556 string s2 = new DateTime (2000, 6, 3).ToString ();
557 Assert.AreEqual (s2, s2.Clone (), "#B1");
558 Assert.AreSame (s2, s2.Clone (), "#B2");
561 [Test] // bug #316666
562 public void CompareNotWorking ()
564 Assert.AreEqual (String.Compare ("A", "a"), 1, "A03");
565 Assert.AreEqual (String.Compare ("a", "A"), -1, "A04");
569 public void CompareNotWorking2 ()
571 string needle = "ab";
572 string haystack = "abbcbacab";
573 Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2, false), "basic substring check #9");
574 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
576 Assert.AreEqual (-1, String.Compare(needle, 0, haystack, i, 2, false), "loop substring check #8/" + i);
582 public void Compare ()
584 string lesser = "abc";
585 string medium = "abcd";
586 string greater = "xyz";
589 Assert.AreEqual (0, String.Compare (null, null));
590 Assert.AreEqual (1, String.Compare (lesser, null));
592 Assert.IsTrue (String.Compare (lesser, greater) < 0);
593 Assert.IsTrue (String.Compare (greater, lesser) > 0);
594 Assert.IsTrue (String.Compare (lesser, lesser) == 0);
595 Assert.IsTrue (String.Compare (lesser, medium) < 0);
597 Assert.IsTrue (String.Compare (lesser, caps, true) == 0);
598 Assert.IsTrue (String.Compare (lesser, caps, false) != 0);
599 Assert.AreEqual (String.Compare ("a", "b"), -1, "A01");
600 Assert.AreEqual (String.Compare ("b", "a"), 1, "A02");
603 // TODO - test with CultureInfo
605 string needle = "ab";
606 string haystack = "abbcbacab";
607 Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2), "basic substring check #1");
608 Assert.AreEqual (-1, String.Compare(needle, 0, haystack, 0, 3), "basic substring check #2");
609 Assert.AreEqual (0, String.Compare("ab", 0, "ab", 0, 2), "basic substring check #3");
610 Assert.AreEqual (0, String.Compare("ab", 0, "ab", 0, 3), "basic substring check #4");
611 Assert.AreEqual (0, String.Compare("abc", 0, "ab", 0, 2), "basic substring check #5");
612 Assert.AreEqual (1, String.Compare("abc", 0, "ab", 0, 5), "basic substring check #6");
613 Assert.AreEqual (-1, String.Compare("ab", 0, "abc", 0, 5), "basic substring check #7");
615 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
617 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2) != 0, "loop substring check #1/" + i);
618 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 3) != 0, "loop substring check #2/" + i);
620 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2), "loop substring check #3/" + i);
621 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 3), "loop substring check #4/" + i);
626 Assert.AreEqual (0, String.Compare(needle, 0, haystack, 0, 2, true), "basic substring check #8");
627 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
629 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2, true) != 0, "loop substring check #5/" + i);
630 Assert.IsTrue (String.Compare(needle, 0, haystack, i, 2, false) != 0, "loop substring check #6/" + i);
632 Assert.AreEqual (0, String.Compare(needle, 0, haystack, i, 2, true), "loop substring check #7/" + i);
636 Assert.AreEqual (0, String.Compare (needle, 0, haystack, 0, 0), "Compare with 0 length");
638 // TODO - extended format call with CultureInfo
642 public void CompareOrdinal ()
644 string lesser = "abc";
645 string medium = "abcd";
646 string greater = "xyz";
648 Assert.AreEqual (0, String.CompareOrdinal (null, null));
649 Assert.AreEqual (1, String.CompareOrdinal (lesser, null));
651 Assert.IsTrue (String.CompareOrdinal (lesser, greater) < 0, "#1");
652 Assert.IsTrue (String.CompareOrdinal (greater, lesser) > 0, "#2");
653 Assert.IsTrue (String.CompareOrdinal (lesser, lesser) == 0, "#3");
654 Assert.IsTrue (String.CompareOrdinal (lesser, medium) < 0, "#4");
656 string needle = "ab";
657 string haystack = "abbcbacab";
658 Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, 0, 2), "basic substring check");
659 Assert.AreEqual (-1, String.CompareOrdinal(needle, 0, haystack, 0, 3), "basic substring miss");
660 for (int i = 1; i <= (haystack.Length - needle.Length); i++) {
662 Assert.IsTrue (String.CompareOrdinal(needle, 0, haystack, i, 2) != 0, "loop substring check " + i);
663 Assert.IsTrue (String.CompareOrdinal(needle, 0, haystack, i, 3) != 0, "loop substring check " + i);
665 Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, i, 2), "loop substring check " + i);
666 Assert.AreEqual (0, String.CompareOrdinal(needle, 0, haystack, i, 3), "loop substring check " + i);
672 public void CompareTo ()
674 string lower = "abc";
675 string greater = "xyz";
676 string lesser = "abc";
678 Assert.IsTrue (lower.CompareTo (greater) < 0);
679 Assert.IsTrue (lower.CompareTo (lower) == 0);
680 Assert.IsTrue (greater.CompareTo (lesser) > 0);
685 public override string ToString ()
692 public void Concat ()
694 string string1 = "string1";
695 string string2 = "string2";
696 string concat = "string1string2";
698 Assert.IsTrue (String.Concat (string1, string2) == concat);
700 Assert.AreEqual (string1, String.Concat (string1, null));
701 Assert.AreEqual (string1, String.Concat (null, string1));
702 Assert.AreEqual (string.Empty, String.Concat (null, null));
704 WeirdToString wts = new WeirdToString ();
705 Assert.AreEqual (string1, String.Concat (string1, wts));
706 Assert.AreEqual (string1, String.Concat (wts, string1));
707 Assert.AreEqual (string.Empty, String.Concat (wts, wts));
708 string [] allstr = new string []{ string1, null, string2, concat };
709 object [] allobj = new object []{ string1, null, string2, concat };
710 string astr = String.Concat (allstr);
711 Assert.AreEqual ("string1string2string1string2", astr);
712 string ostr = String.Concat (allobj);
713 Assert.AreEqual (astr, ostr);
719 string s1 = "original";
720 string s2 = String.Copy(s1);
721 Assert.AreEqual (s1, s2, "#1");
722 Assert.IsTrue (!object.ReferenceEquals (s1, s2), "#2");
726 public void Copy_Str_Null ()
729 String.Copy ((string) null);
731 } catch (ArgumentNullException ex) {
732 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
733 Assert.IsNull (ex.InnerException, "#3");
734 Assert.IsNotNull (ex.Message, "#4");
735 Assert.AreEqual ("str", ex.ParamName, "#5");
740 public void CopyTo ()
742 string s1 = "original";
743 char[] c1 = new char[s1.Length];
744 string s2 = new String(c1);
745 Assert.IsTrue (!s1.Equals(s2), "#1");
746 for (int i = 0; i < s1.Length; i++) {
747 s1.CopyTo(i, c1, i, 1);
750 Assert.AreEqual (s1, s2, "#2");
754 public void CopyTo_Count_Negative ()
756 char [] dest = new char [4];
758 "Mono".CopyTo (0, dest, 0, -1);
760 } catch (ArgumentOutOfRangeException ex) {
761 // Count cannot be less than zero
762 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
763 Assert.IsNull (ex.InnerException, "#3");
764 Assert.IsNotNull (ex.Message, "#4");
765 Assert.AreEqual ("count", ex.ParamName, "#5");
770 public void CopyTo_Count_Overflow ()
772 char [] dest = new char [4];
774 "Mono".CopyTo (0, dest, 0, Int32.MaxValue);
776 } catch (ArgumentOutOfRangeException ex) {
777 // Index and count must refer to a location within the
779 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
780 Assert.IsNull (ex.InnerException, "#3");
781 Assert.IsNotNull (ex.Message, "#4");
782 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
787 public void CopyTo_Destination_Null ()
789 string s = "original";
792 s.CopyTo (0, (char []) null, 0, s.Length);
794 } catch (ArgumentNullException ex) {
795 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
796 Assert.IsNull (ex.InnerException, "#3");
797 Assert.IsNotNull (ex.Message, "#4");
798 Assert.AreEqual ("destination", ex.ParamName, "#5");
803 public void CopyTo_DestinationIndex_Negative ()
805 char [] dest = new char [4];
807 "Mono".CopyTo (0, dest, -1, 4);
809 } catch (ArgumentOutOfRangeException ex) {
810 // Index and count must refer to a location within the
812 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
813 Assert.IsNull (ex.InnerException, "#3");
814 Assert.IsNotNull (ex.Message, "#4");
815 Assert.AreEqual ("destinationIndex", ex.ParamName, "#5");
820 public void CopyTo_DestinationIndex_Overflow ()
822 char [] dest = new char [4];
824 "Mono".CopyTo (0, dest, Int32.MaxValue, 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_SourceIndex_Negative ()
839 char [] dest = new char [4];
841 "Mono".CopyTo (-1, dest, 0, 4);
843 } catch (ArgumentOutOfRangeException ex) {
844 // Index was out of range. Must be non-negative and
845 // less than the size of the collection
846 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
847 Assert.IsNull (ex.InnerException, "#3");
848 Assert.IsNotNull (ex.Message, "#4");
849 Assert.AreEqual ("sourceIndex", ex.ParamName, "#5");
854 public void CopyTo_SourceIndex_Overflow ()
856 char[] dest = new char [4];
858 "Mono".CopyTo (Int32.MaxValue, dest, 0, 4);
860 } catch (ArgumentOutOfRangeException ex) {
861 // Index and count must refer to a location within the
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");
870 [Test] // EndsWith (String)
871 public void EndsWith1 ()
875 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
878 Assert.IsTrue (s.EndsWith ("bC"), "#A1");
879 Assert.IsTrue (!s.EndsWith ("bc"), "#A1");
880 Assert.IsTrue (!s.EndsWith ("dc"), "#A2");
881 Assert.IsTrue (!s.EndsWith ("LAbC"), "#A3");
882 Assert.IsTrue (s.EndsWith (string.Empty), "#A4");
883 Assert.IsTrue (!s.EndsWith ("Ab"), "#A5");
884 Assert.IsTrue (!s.EndsWith ("Abc"), "#A6");
885 Assert.IsTrue (s.EndsWith ("AbC"), "#A7");
889 Assert.IsTrue (s.EndsWith ("ai"), "#B1");
890 Assert.IsTrue (!s.EndsWith ("AI"), "#B2");
891 Assert.IsTrue (!s.EndsWith ("LTai"), "#B3");
892 Assert.IsTrue (s.EndsWith (string.Empty), "#B4");
893 Assert.IsTrue (!s.EndsWith ("Ta"), "#B5");
894 Assert.IsTrue (!s.EndsWith ("tai"), "#B6");
895 Assert.IsTrue (s.EndsWith ("Tai"), "#B7");
897 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
899 Assert.IsTrue (s.EndsWith ("ai"), "#C1");
900 Assert.IsTrue (!s.EndsWith ("AI"), "#C2");
901 Assert.IsTrue (!s.EndsWith ("LTai"), "#C3");
902 Assert.IsTrue (s.EndsWith (string.Empty), "#C4");
903 Assert.IsTrue (!s.EndsWith ("Ta"), "#C5");
904 Assert.IsTrue (!s.EndsWith ("tai"), "#C6");
905 Assert.IsTrue (s.EndsWith ("Tai"), "#C7");
908 [Test] // EndsWith (String)
909 public void EndsWith1_Value_Null ()
912 "ABC".EndsWith ((string) null);
914 } catch (ArgumentNullException ex) {
915 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
916 Assert.IsNull (ex.InnerException, "#3");
917 Assert.IsNotNull (ex.Message, "#4");
918 Assert.AreEqual ("value", ex.ParamName, "#5");
923 [Test] // EndsWith (String, StringComparison)
924 public void EndsWith2_ComparisonType_Invalid ()
927 "ABC".EndsWith ("C", (StringComparison) 80);
929 } catch (ArgumentException ex) {
930 // The string comparison type passed in is currently
932 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
933 Assert.IsNull (ex.InnerException, "#3");
934 Assert.IsNotNull (ex.Message, "#4");
935 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
939 [Test] // EndsWith (String, StringComparison)
940 public void EndsWith2_Value_Null ()
943 "ABC".EndsWith ((string) null, StringComparison.CurrentCulture);
945 } catch (ArgumentNullException ex) {
946 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
947 Assert.IsNull (ex.InnerException, "#3");
948 Assert.IsNotNull (ex.Message, "#4");
949 Assert.AreEqual ("value", ex.ParamName, "#5");
953 [Test] // EndsWith (String, Boolean, CultureInfo)
954 public void EndsWith3 ()
960 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
965 Assert.IsTrue (!s.EndsWith ("bc", ignorecase, culture), "#A1");
966 Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#A2");
967 Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#A3");
968 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#A4");
969 Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#A5");
970 Assert.IsTrue (!s.EndsWith ("Abc", ignorecase, culture), "#A6");
971 Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#A7");
974 Assert.IsTrue (s.EndsWith ("bc", ignorecase, culture), "#B1");
975 Assert.IsTrue (!s.EndsWith ("dc", ignorecase, culture), "#B2");
976 Assert.IsTrue (!s.EndsWith ("LAbC", ignorecase, culture), "#B3");
977 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#B4");
978 Assert.IsTrue (!s.EndsWith ("Ab", ignorecase, culture), "#B5");
979 Assert.IsTrue (s.EndsWith ("Abc", ignorecase, culture), "#B6");
980 Assert.IsTrue (s.EndsWith ("AbC", ignorecase, culture), "#B7");
986 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#C1");
987 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#C2");
988 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#C3");
989 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#C4");
990 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#C5");
991 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#C6");
992 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#C7");
995 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#D1");
996 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#D2");
997 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#D3");
998 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#D4");
999 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#D5");
1000 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#D6");
1001 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#D7");
1004 culture = new CultureInfo ("en-US");
1007 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#E1");
1008 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#E2");
1009 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#E3");
1010 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#E4");
1011 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#E5");
1012 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#E6");
1013 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#E7");
1016 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#F1");
1017 Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#F2");
1018 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#F3");
1019 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#F4");
1020 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#F5");
1021 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#F6");
1022 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#F7");
1024 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1028 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#G1");
1029 Assert.IsTrue (!s.EndsWith ("AI", ignorecase, culture), "#G2");
1030 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#G3");
1031 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#G4");
1032 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#G5");
1033 Assert.IsTrue (!s.EndsWith ("tai", ignorecase, culture), "#G6");
1034 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#G7");
1037 Assert.IsTrue (s.EndsWith ("ai", ignorecase, culture), "#H1");
1038 Assert.IsTrue (s.EndsWith ("AI", ignorecase, culture), "#H2");
1039 Assert.IsTrue (!s.EndsWith ("LTai", ignorecase, culture), "#H3");
1040 Assert.IsTrue (s.EndsWith (string.Empty, ignorecase, culture), "#H4");
1041 Assert.IsTrue (!s.EndsWith ("Ta", ignorecase, culture), "#H5");
1042 Assert.IsTrue (s.EndsWith ("tai", ignorecase, culture), "#H6");
1043 Assert.IsTrue (s.EndsWith ("Tai", ignorecase, culture), "#H7");
1046 [Test] // EndsWith (String, Boolean, CultureInfo)
1047 public void EndsWith3_Value_Null ()
1050 "ABC".EndsWith ((string) null, true, null);
1052 } catch (ArgumentNullException ex) {
1053 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1054 Assert.IsNull (ex.InnerException, "#3");
1055 Assert.IsNotNull (ex.Message, "#4");
1056 Assert.AreEqual ("value", ex.ParamName, "#5");
1062 public void TestEquals ()
1064 string s1 = "original";
1065 string yes = "original";
1068 string s1s1 = s1 + s1;
1070 Assert.IsTrue (!s1.Equals (null), "No match for null");
1071 Assert.IsTrue (s1.Equals (y), "Should match object");
1072 Assert.IsTrue (s1.Equals (yes), "Should match");
1073 Assert.IsTrue (!s1.Equals (no), "Shouldn't match");
1075 Assert.IsTrue (String.Equals (null, null), "Static nulls should match");
1076 Assert.IsTrue (String.Equals (s1, yes), "Should match");
1077 Assert.IsTrue (!String.Equals (s1, no), "Shouldn't match");
1079 Assert.AreEqual (false, s1s1.Equals (y), "Equals (object)");
1083 public void TestFormat ()
1085 Assert.AreEqual (string.Empty, String.Format (string.Empty, 0), "Empty format string.");
1086 Assert.AreEqual ("100", String.Format ("{0}", 100), "Single argument.");
1087 Assert.AreEqual ("X 37X", String.Format ("X{0,5}X", 37), "Single argument, right justified.");
1088 Assert.AreEqual ("X37 X", String.Format ("X{0,-5}X", 37), "Single argument, left justified.");
1089 Assert.AreEqual (" 7d", String.Format ("{0, 4:x}", 125), "Whitespace in specifier");
1090 Assert.AreEqual ("The 3 wise men.", String.Format ("The {0} wise {1}.", 3, "men"), "Two arguments.");
1091 Assert.AreEqual ("do re me fa so.", String.Format ("{0} re {1} fa {2}.", "do", "me", "so"), "Three arguments.");
1092 Assert.AreEqual ("###00c0ffee#", String.Format ("###{0:x8}#", 0xc0ffee), "Formatted argument.");
1093 Assert.AreEqual ("# 033#", String.Format ("#{0,5:x3}#", 0x33), "Formatted argument, right justified.");
1094 Assert.AreEqual ("#033 #", String.Format ("#{0,-5:x3}#", 0x33), "Formatted argument, left justified.");
1095 Assert.AreEqual ("typedef struct _MonoObject { ... } MonoObject;", String.Format ("typedef struct _{0} {{ ... }} MonoObject;", "MonoObject"), "Escaped bracket");
1096 Assert.AreEqual ("Could not find file \"a/b\"", String.Format ("Could not find file \"{0}\"", "a/b"), "With Slash");
1097 Assert.AreEqual ("Could not find file \"a\\b\"", String.Format ("Could not find file \"{0}\"", "a\\b"), "With BackSlash");
1100 [Test] // Format (String, Object)
1101 public void Format1_Format_Null ()
1104 String.Format (null, 1);
1106 } catch (ArgumentNullException ex) {
1107 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1108 Assert.IsNull (ex.InnerException, "#3");
1109 Assert.IsNotNull (ex.Message, "#4");
1110 Assert.AreEqual ("format", ex.ParamName, "#5");
1114 [Test] // Format (String, Object [])
1115 public void Format2_Format_Null ()
1118 String.Format (null, new object [] { 2 });
1120 } catch (ArgumentNullException ex) {
1121 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1122 Assert.IsNull (ex.InnerException, "#3");
1123 Assert.IsNotNull (ex.Message, "#4");
1124 Assert.AreEqual ("format", ex.ParamName, "#5");
1128 [Test] // Format (String, Object [])
1129 public void Format2_Args_Null ()
1132 String.Format ("text", (object []) null);
1134 } catch (ArgumentNullException ex) {
1135 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1136 Assert.IsNull (ex.InnerException, "#3");
1137 Assert.IsNotNull (ex.Message, "#4");
1138 Assert.AreEqual ("args", ex.ParamName, "#5");
1142 [Test] // Format (IFormatProvider, String, Object [])
1143 public void Format3_Format_Null ()
1146 String.Format (CultureInfo.InvariantCulture, null,
1147 new object [] { 3 });
1149 } catch (ArgumentNullException ex) {
1150 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1151 Assert.IsNull (ex.InnerException, "#3");
1152 Assert.IsNotNull (ex.Message, "#4");
1153 Assert.AreEqual ("format", ex.ParamName, "#5");
1157 [Test] // Format (IFormatProvider, String, Object [])
1158 public void Format3_Args_Null ()
1161 String.Format (CultureInfo.InvariantCulture, "text",
1164 } catch (ArgumentNullException ex) {
1165 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1166 Assert.IsNull (ex.InnerException, "#3");
1167 Assert.IsNotNull (ex.Message, "#4");
1168 Assert.AreEqual ("args", ex.ParamName, "#5");
1172 [Test] // Format (String, Object, Object)
1173 public void Format4_Format_Null ()
1176 String.Format (null, 4, 5);
1178 } catch (ArgumentNullException ex) {
1179 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1180 Assert.IsNull (ex.InnerException, "#3");
1181 Assert.IsNotNull (ex.Message, "#4");
1182 Assert.AreEqual ("format", ex.ParamName, "#5");
1186 [Test] // Format (String, Object, Object, Object)
1187 public void Format5_Format_Null ()
1190 String.Format (null, 4, 5, 6);
1192 } catch (ArgumentNullException ex) {
1193 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1194 Assert.IsNull (ex.InnerException, "#3");
1195 Assert.IsNotNull (ex.Message, "#4");
1196 Assert.AreEqual ("format", ex.ParamName, "#5");
1201 public void TestGetEnumerator ()
1203 string s1 = "original";
1204 char[] c1 = new char[s1.Length];
1205 string s2 = new String(c1);
1206 Assert.IsTrue (!s1.Equals(s2), "pre-enumerated string should not match");
1207 CharEnumerator en = s1.GetEnumerator();
1208 Assert.IsNotNull (en, "null enumerator");
1210 for (int i = 0; i < s1.Length; i++) {
1214 s2 = new String(c1);
1215 Assert.AreEqual (s1, s2, "enumerated string should match");
1219 public void TestGetHashCode ()
1221 string s1 = "original";
1222 // TODO - weak test, currently. Just verifies determinicity.
1223 Assert.AreEqual (s1.GetHashCode(), s1.GetHashCode(), "same string, same hash code");
1227 public void TestGetType ()
1229 string s1 = "original";
1230 Assert.AreEqual ("System.String", s1.GetType().ToString(), "String type");
1234 public void TestGetTypeCode ()
1236 string s1 = "original";
1237 Assert.IsTrue (s1.GetTypeCode().Equals(TypeCode.String));
1241 public void IndexOf ()
1243 string s1 = "original";
1246 s1.IndexOf ('q', s1.Length + 1);
1247 Assert.Fail ("#A1");
1248 } catch (ArgumentOutOfRangeException ex) {
1249 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1250 Assert.IsNull (ex.InnerException, "#A3");
1251 Assert.IsNotNull (ex.Message, "#A4");
1252 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
1256 s1.IndexOf ('q', s1.Length + 1, 1);
1257 Assert.Fail ("#B1");
1258 } catch (ArgumentOutOfRangeException ex) {
1259 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1260 Assert.IsNull (ex.InnerException, "#B3");
1261 Assert.IsNotNull (ex.Message, "#B4");
1262 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
1266 s1.IndexOf ("huh", s1.Length + 1);
1267 Assert.Fail ("#C1");
1268 } catch (ArgumentOutOfRangeException ex) {
1269 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1270 Assert.IsNull (ex.InnerException, "#C3");
1271 Assert.IsNotNull (ex.Message, "#C4");
1272 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
1275 Assert.AreEqual (1, s1.IndexOf('r'), "basic char index");
1276 Assert.AreEqual (2, s1.IndexOf('i'), "basic char index 2");
1277 Assert.AreEqual (-1, s1.IndexOf('q'), "basic char index - no");
1279 Assert.AreEqual (1, s1.IndexOf("rig"), "basic string index");
1280 Assert.AreEqual (2, s1.IndexOf("i"), "basic string index 2");
1281 Assert.AreEqual (0, string.Empty.IndexOf(string.Empty), "basic string index 3");
1282 Assert.AreEqual (0, "ABC".IndexOf(string.Empty), "basic string index 4");
1283 Assert.AreEqual (-1, s1.IndexOf("rag"), "basic string index - no");
1285 Assert.AreEqual (1, s1.IndexOf('r', 1), "stepped char index");
1286 Assert.AreEqual (2, s1.IndexOf('i', 1), "stepped char index 2");
1287 Assert.AreEqual (4, s1.IndexOf('i', 3), "stepped char index 3");
1288 Assert.AreEqual (-1, s1.IndexOf('i', 5), "stepped char index 4");
1289 Assert.AreEqual (-1, s1.IndexOf('l', s1.Length), "stepped char index 5");
1291 Assert.AreEqual (1, s1.IndexOf('r', 1, 1), "stepped limited char index");
1292 Assert.AreEqual (-1, s1.IndexOf('r', 0, 1), "stepped limited char index");
1293 Assert.AreEqual (2, s1.IndexOf('i', 1, 3), "stepped limited char index");
1294 Assert.AreEqual (4, s1.IndexOf('i', 3, 3), "stepped limited char index");
1295 Assert.AreEqual (-1, s1.IndexOf('i', 5, 3), "stepped limited char index");
1297 s1 = "original original";
1298 Assert.AreEqual (0, s1.IndexOf("original", 0), "stepped string index 1");
1299 Assert.AreEqual (9, s1.IndexOf("original", 1), "stepped string index 2");
1300 Assert.AreEqual (-1, s1.IndexOf("original", 10), "stepped string index 3");
1301 Assert.AreEqual (3, s1.IndexOf(string.Empty, 3), "stepped string index 4");
1302 Assert.AreEqual (1, s1.IndexOf("rig", 0, 5), "stepped limited string index 1");
1303 Assert.AreEqual (-1, s1.IndexOf("rig", 0, 3), "stepped limited string index 2");
1304 Assert.AreEqual (10, s1.IndexOf("rig", 2, 15), "stepped limited string index 3");
1305 Assert.AreEqual (-1, s1.IndexOf("rig", 2, 3), "stepped limited string index 4");
1306 Assert.AreEqual (2, s1.IndexOf(string.Empty, 2, 3), "stepped limited string index 5");
1308 string s2 = "QBitArray::bitarr_data";
1309 Assert.AreEqual (9, s2.IndexOf ("::"), "bug #62160");
1312 [Test] // IndexOf (String)
1313 public void IndexOf2_Value_Null ()
1316 "Mono".IndexOf ((string) null);
1318 } catch (ArgumentNullException ex) {
1319 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1320 Assert.IsNull (ex.InnerException, "#3");
1321 Assert.IsNotNull (ex.Message, "#4");
1323 Assert.AreEqual ("value", ex.ParamName, "#5");
1325 //Fixme: Does it really make sense to check for obsolete
1326 // parameter names. Then case this in string.
1327 //Assert.AreEqual ("string2", ex.ParamName, "#5");
1332 [Test] // IndexOf (Char, Int32)
1333 public void IndexOf3 ()
1335 string s = "testing123456";
1337 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1339 Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#A1");
1340 Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#A2");
1341 Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#A3");
1342 Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#A4");
1343 Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#A5");
1344 Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#A6");
1345 Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#A7");
1346 Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#A8");
1348 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1350 Assert.AreEqual (-1, s.IndexOf ('a', s.Length), "#B1");
1351 Assert.AreEqual (-1, s.IndexOf ('6', s.Length), "#B2");
1352 Assert.AreEqual (-1, s.IndexOf ('t', s.Length), "#B3");
1353 Assert.AreEqual (-1, s.IndexOf ('T', s.Length), "#B4");
1354 Assert.AreEqual (-1, s.IndexOf ('i', s.Length), "#B5");
1355 Assert.AreEqual (-1, s.IndexOf ('I', s.Length), "#B6");
1356 Assert.AreEqual (-1, s.IndexOf ('q', s.Length), "#B7");
1357 Assert.AreEqual (-1, s.IndexOf ('3', s.Length), "#B8");
1360 [Test] // IndexOf (String, Int32)
1361 public void IndexOf4 ()
1363 string s = "testing123456";
1365 Assert.AreEqual (-1, s.IndexOf ("IN", 3), "#1");
1366 Assert.AreEqual (4, s.IndexOf ("in", 3), "#2");
1367 Assert.AreEqual (-1, s.IndexOf ("in", 5), "#3");
1368 Assert.AreEqual (7, s.IndexOf ("1", 5), "#4");
1369 Assert.AreEqual (12, s.IndexOf ("6", 12), "#5");
1370 Assert.AreEqual (0, s.IndexOf ("testing123456", 0), "#6");
1371 Assert.AreEqual (-1, s.IndexOf ("testing123456", 1), "#7");
1372 Assert.AreEqual (5, s.IndexOf (string.Empty, 5), "#8");
1373 Assert.AreEqual (0, s.IndexOf (string.Empty, 0), "#9");
1376 [Test] // IndexOf (String, Int32)
1377 public void IndexOf4_Value_Null ()
1380 "Mono".IndexOf ((string) null, 1);
1382 } catch (ArgumentNullException ex) {
1383 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1384 Assert.IsNull (ex.InnerException, "#3");
1385 Assert.IsNotNull (ex.Message, "#4");
1387 Assert.AreEqual ("value", ex.ParamName, "#5");
1389 Assert.AreEqual ("string2", ex.ParamName, "#5");
1395 [Test] // IndexOf (String, StringComparison)
1396 public void IndexOf5 ()
1398 string s = "testing123456";
1399 StringComparison comparison_type;
1401 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1403 comparison_type = StringComparison.CurrentCulture;
1404 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#A1");
1405 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#A2");
1406 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#A3");
1407 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#A4");
1408 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#A5");
1409 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#A6");
1410 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#A7");
1411 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#A8");
1412 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#A9");
1414 comparison_type = StringComparison.CurrentCultureIgnoreCase;
1415 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#B1");
1416 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#B2");
1417 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#B3");
1418 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#B4");
1419 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#B5");
1420 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#B6");
1421 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#B7");
1422 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#B8");
1423 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#B9");
1425 comparison_type = StringComparison.InvariantCulture;
1426 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#C1");
1427 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#C2");
1428 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#C3");
1429 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#C4");
1430 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#C5");
1431 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#C6");
1432 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#C7");
1433 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#C8");
1434 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#C9");
1436 comparison_type = StringComparison.InvariantCultureIgnoreCase;
1437 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#D1");
1438 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#D2");
1439 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#D3");
1440 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#D4");
1441 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#D5");
1442 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#D6");
1443 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#D7");
1444 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#D8");
1445 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#D9");
1447 comparison_type = StringComparison.Ordinal;
1448 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#E1");
1449 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#E2");
1450 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#E3");
1451 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#E4");
1452 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#E5");
1453 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#E6");
1454 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#E7");
1455 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#E8");
1456 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#E9");
1458 comparison_type = StringComparison.OrdinalIgnoreCase;
1459 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#F1");
1460 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#F2");
1461 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#F3");
1462 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#F4");
1463 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#F5");
1464 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#F6");
1465 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#F7");
1466 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#F8");
1467 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#F9");
1469 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1471 comparison_type = StringComparison.CurrentCulture;
1472 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#G1");
1473 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#G2");
1474 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#G3");
1475 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#G4");
1476 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#G5");
1477 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#G6");
1478 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#G7");
1479 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#G8");
1480 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#G9");
1482 comparison_type = StringComparison.CurrentCultureIgnoreCase;
1483 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#H1");
1484 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#H2");
1485 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#H3");
1486 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#H4");
1487 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#H5");
1488 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#H6");
1489 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#H7");
1490 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#H8");
1491 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#H9");
1493 comparison_type = StringComparison.InvariantCulture;
1494 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#I1");
1495 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#I2");
1496 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#I3");
1497 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#I4");
1498 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#I5");
1499 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#I6");
1500 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#I7");
1501 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#I8");
1502 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#I9");
1504 comparison_type = StringComparison.InvariantCultureIgnoreCase;
1505 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#J1");
1506 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#J2");
1507 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#J3");
1508 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#J4");
1509 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#J5");
1510 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#J6");
1511 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#J7");
1512 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#J8");
1513 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#J9");
1515 comparison_type = StringComparison.Ordinal;
1516 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#K1");
1517 Assert.AreEqual (-1, s.IndexOf ("NG", comparison_type), "#K2");
1518 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#K3");
1519 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#K4");
1520 Assert.AreEqual (-1, s.IndexOf ("T", comparison_type), "#K5");
1521 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#K6");
1522 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#K7");
1523 Assert.AreEqual (-1, s.IndexOf ("TIN", comparison_type), "#K8");
1524 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#K9");
1526 comparison_type = StringComparison.OrdinalIgnoreCase;
1527 Assert.AreEqual (7, s.IndexOf ("123", comparison_type), "#L1");
1528 Assert.AreEqual (5, s.IndexOf ("NG", comparison_type), "#L2");
1529 Assert.AreEqual (-1, s.IndexOf ("nga", comparison_type), "#L3");
1530 Assert.AreEqual (0, s.IndexOf ("t", comparison_type), "#L4");
1531 Assert.AreEqual (0, s.IndexOf ("T", comparison_type), "#L5");
1532 Assert.AreEqual (12, s.IndexOf ("6", comparison_type), "#L6");
1533 Assert.AreEqual (3, s.IndexOf ("tin", comparison_type), "#L7");
1534 Assert.AreEqual (3, s.IndexOf ("TIN", comparison_type), "#L8");
1535 Assert.AreEqual (0, s.IndexOf (string.Empty, comparison_type), "#L9");
1537 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, comparison_type), "#M");
1540 [Test] // IndexOf (String, StringComparison)
1541 public void IndexOf5_ComparisonType_Invalid ()
1544 "Mono".IndexOf (string.Empty, (StringComparison) Int32.MinValue);
1546 } catch (ArgumentException ex) {
1547 // The string comparison type passed in is currently
1549 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1550 Assert.IsNull (ex.InnerException, "#3");
1551 Assert.IsNotNull (ex.Message, "#4");
1552 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
1556 [Test] // IndexOf (String, StringComparison)
1557 public void IndexOf5_Value_Null ()
1560 "Mono".IndexOf ((string) null, StringComparison.Ordinal);
1562 } catch (ArgumentNullException ex) {
1563 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1564 Assert.IsNull (ex.InnerException, "#3");
1565 Assert.IsNotNull (ex.Message, "#4");
1566 Assert.AreEqual ("value", ex.ParamName, "#5");
1571 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1572 public void IndexOfStringComparisonOrdinalRangeException1 ()
1574 "Mono".IndexOf ("no", 5, StringComparison.Ordinal);
1578 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1579 public void IndexOfStringComparisonOrdinalRangeException2 ()
1581 "Mono".IndexOf ("no", 1, 5, StringComparison.Ordinal);
1585 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1586 public void IndexOfStringComparisonOrdinalIgnoreCaseRangeException1 ()
1588 "Mono".IndexOf ("no", 5, StringComparison.OrdinalIgnoreCase);
1592 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1593 public void IndexOfStringComparisonOrdinalIgnoreCaseRangeException2 ()
1595 "Mono".IndexOf ("no", 1, 5, StringComparison.OrdinalIgnoreCase);
1599 public void IndexOfStringComparison ()
1601 string text = "testing123456";
1602 string text2 = "123";
1603 string text3 = "NG";
1605 Assert.AreEqual (7, text.IndexOf (text2, StringComparison.Ordinal), "#1-1");
1606 Assert.AreEqual (5, text.IndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1");
1608 Assert.AreEqual (7, text.IndexOf (text2, 0, StringComparison.Ordinal), "#1-2");
1609 Assert.AreEqual (5, text.IndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-2");
1611 Assert.AreEqual (7, text.IndexOf (text2, 1, StringComparison.Ordinal), "#1-3");
1612 Assert.AreEqual (5, text.IndexOf (text3, 1, StringComparison.OrdinalIgnoreCase), "#2-3");
1614 Assert.AreEqual (7, text.IndexOf (text2, 6, StringComparison.Ordinal), "#1-4");
1615 Assert.AreEqual (-1, text.IndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4");
1617 Assert.AreEqual (7, text.IndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5");
1618 Assert.AreEqual (-1, text.IndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5");
1620 Assert.AreEqual (-1, text.IndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6");
1621 Assert.AreEqual (-1, text.IndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6");
1623 Assert.AreEqual (-1, text.IndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7");
1624 Assert.AreEqual (-1, text.IndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7");
1626 Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.Ordinal), "#3-1");
1627 Assert.AreEqual (0, text.IndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2");
1629 Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.Ordinal), "#4-1");
1630 Assert.AreEqual (-1, text.IndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2");
1632 Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.Ordinal), "#4-1");
1633 Assert.AreEqual (-1, text.IndexOf (text4, 13, 0, StringComparison.OrdinalIgnoreCase), "#4-2");
1635 Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.Ordinal), "#5-1");
1636 Assert.AreEqual (12, text.IndexOf ("6", 12, 1, StringComparison.OrdinalIgnoreCase), "#5-2");
1640 public void IndexOfStringComparisonOrdinal ()
1642 string text = "testing123456";
1643 Assert.AreEqual (10, text.IndexOf ("456", StringComparison.Ordinal), "#1");
1644 Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.Ordinal), "#2");
1645 Assert.AreEqual (0, text.IndexOf ("te", StringComparison.Ordinal), "#3");
1646 Assert.AreEqual (2, text.IndexOf ("s", StringComparison.Ordinal), "#4");
1647 Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.Ordinal), "#5");
1648 Assert.AreEqual (-1, text.IndexOf ("S", StringComparison.Ordinal), "#6");
1652 public void IndexOfStringComparisonOrdinalIgnoreCase ()
1654 string text = "testing123456";
1655 Assert.AreEqual (10, text.IndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1");
1656 Assert.AreEqual (-1, text.IndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2");
1657 Assert.AreEqual (0, text.IndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3");
1658 Assert.AreEqual (2, text.IndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4");
1659 Assert.AreEqual (-1, text.IndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5");
1660 Assert.AreEqual (2, text.IndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6");
1664 public void IndexOfOrdinalCountSmallerThanValueString ()
1666 Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.Ordinal), "#1");
1667 Assert.AreEqual (-1, "Test".IndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#2");
1668 Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.Ordinal), "#3");
1669 Assert.AreEqual (-1, "Test".LastIndexOf ("ST", 2, 1, StringComparison.OrdinalIgnoreCase), "#4");
1673 [Test] // IndexOf (Char, Int32, Int32)
1674 public void IndexOf6_Count_Negative ()
1677 "Mono".IndexOf ('o', 1, -1);
1679 } catch (ArgumentOutOfRangeException ex) {
1680 // Count must be positive and count must refer to a
1681 // location within the string/array/collection
1682 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1683 Assert.IsNull (ex.InnerException, "#3");
1684 Assert.IsNotNull (ex.Message, "#4");
1685 Assert.AreEqual ("count", ex.ParamName, "#5");
1689 [Test] // IndexOf (Char, Int32, Int32)
1690 public void IndexOf6_Count_Overflow ()
1693 "Mono".IndexOf ('o', 1, Int32.MaxValue);
1695 } catch (ArgumentOutOfRangeException ex) {
1696 // Count must be positive and count must refer to a
1697 // location within the string/array/collection
1698 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1699 Assert.IsNull (ex.InnerException, "#3");
1700 Assert.IsNotNull (ex.Message, "#4");
1701 Assert.AreEqual ("count", ex.ParamName, "#5");
1705 [Test] // IndexOf (Char, Int32, Int32)
1706 public void IndexOf6_StartIndex_Negative ()
1709 "Mono".IndexOf ('o', -1, 1);
1711 } catch (ArgumentOutOfRangeException ex) {
1712 // Index was out of range. Must be non-negative and
1713 // less than the size of the collection
1714 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1715 Assert.IsNull (ex.InnerException, "#3");
1716 Assert.IsNotNull (ex.Message, "#4");
1717 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1721 [Test] // IndexOf (Char, Int32, Int32)
1722 public void IndexOf6_StartIndex_Overflow ()
1724 string s = "testing123456";
1727 s.IndexOf ('o', s.Length + 1, 1);
1729 } catch (ArgumentOutOfRangeException ex) {
1730 // Index was out of range. Must be non-negative and
1731 // less than the size of the collection
1732 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1733 Assert.IsNull (ex.InnerException, "#3");
1734 Assert.IsNotNull (ex.Message, "#4");
1735 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1739 [Test] // IndexOf (String, Int32, Int32)
1740 public void IndexOf7 ()
1742 string s = "testing123456test";
1744 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
1746 Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#A1");
1747 Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#A2");
1748 Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#A3");
1749 Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#A4");
1750 Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#A5");
1751 Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#A6");
1753 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#B1");
1754 Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#B2");
1755 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#B3");
1756 Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#B4");
1757 Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#B5");
1758 Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#B6");
1760 Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#C1");
1761 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#C2");
1762 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#C3");
1763 Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#C4");
1764 Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#C5");
1765 Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#C6");
1767 Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#D1");
1768 Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#D2");
1769 Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#D3");
1770 Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#D4");
1771 Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#D5");
1772 Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#D6");
1774 Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#E1");
1775 Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#E2");
1776 Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#E3");
1777 Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#E4");
1778 Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#E5");
1779 Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#E6");
1780 Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#E7");
1781 Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#E8");
1782 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#E9");
1783 Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#E10");
1785 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1787 Assert.AreEqual (-1, s.IndexOf ("123", 4, 5), "#F1");
1788 Assert.AreEqual (7, s.IndexOf ("123", 4, 6), "#F2");
1789 Assert.AreEqual (-1, s.IndexOf ("123", 5, 4), "#F3");
1790 Assert.AreEqual (7, s.IndexOf ("123", 5, 5), "#F4");
1791 Assert.AreEqual (7, s.IndexOf ("123", 0, s.Length), "#F5");
1792 Assert.AreEqual (-1, s.IndexOf ("123", s.Length, 0), "#F6");
1794 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 3), "#G1");
1795 Assert.AreEqual (3, s.IndexOf ("tin", 3, 3), "#G2");
1796 Assert.AreEqual (-1, s.IndexOf ("tin", 2, 2), "#G3");
1797 Assert.AreEqual (-1, s.IndexOf ("tin", 1, 4), "#G4");
1798 Assert.AreEqual (3, s.IndexOf ("tin", 0, s.Length), "#G5");
1799 Assert.AreEqual (-1, s.IndexOf ("tin", s.Length, 0), "#G6");
1801 Assert.AreEqual (6, s.IndexOf ("g12", 4, 5), "#H1");
1802 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 2), "#H2");
1803 Assert.AreEqual (-1, s.IndexOf ("g12", 5, 3), "#H3");
1804 Assert.AreEqual (6, s.IndexOf ("g12", 6, 4), "#H4");
1805 Assert.AreEqual (6, s.IndexOf ("g12", 0, s.Length), "#H5");
1806 Assert.AreEqual (-1, s.IndexOf ("g12", s.Length, 0), "#H6");
1808 Assert.AreEqual (1, s.IndexOf ("est", 0, 5), "#I1");
1809 Assert.AreEqual (-1, s.IndexOf ("est", 1, 2), "#I2");
1810 Assert.AreEqual (-1, s.IndexOf ("est", 2, 10), "#I3");
1811 Assert.AreEqual (14, s.IndexOf ("est", 7, 10), "#I4");
1812 Assert.AreEqual (1, s.IndexOf ("est", 0, s.Length), "#I5");
1813 Assert.AreEqual (-1, s.IndexOf ("est", s.Length, 0), "#I6");
1815 Assert.AreEqual (-1, s.IndexOf ("T", 0, s.Length), "#J1");
1816 Assert.AreEqual (4, s.IndexOf ("i", 0, s.Length), "#J2");
1817 Assert.AreEqual (-1, s.IndexOf ("I", 0, s.Length), "#J3");
1818 Assert.AreEqual (12, s.IndexOf ("6", 0, s.Length), "#J4");
1819 Assert.AreEqual (0, s.IndexOf ("testing123456", 0, s.Length), "#J5");
1820 Assert.AreEqual (-1, s.IndexOf ("testing1234567", 0, s.Length), "#J6");
1821 Assert.AreEqual (0, s.IndexOf (string.Empty, 0, 0), "#J7");
1822 Assert.AreEqual (4, s.IndexOf (string.Empty, 4, 3), "#J8");
1823 Assert.AreEqual (0, string.Empty.IndexOf (string.Empty, 0, 0), "#J9");
1824 Assert.AreEqual (-1, string.Empty.IndexOf ("abc", 0, 0), "#J10");
1827 [Test] // IndexOf (String, Int32, Int32)
1828 public void IndexOf7_Count_Negative ()
1831 "Mono".IndexOf ("no", 1, -1);
1833 } catch (ArgumentOutOfRangeException ex) {
1834 // Count must be positive and count must refer to a
1835 // location within the string/array/collection
1836 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1837 Assert.IsNull (ex.InnerException, "#3");
1838 Assert.IsNotNull (ex.Message, "#4");
1839 Assert.AreEqual ("count", ex.ParamName, "#5");
1843 [Test] // IndexOf (String, Int32, Int32)
1844 public void IndexOf7_Count_Overflow ()
1846 string s = "testing123456";
1849 s.IndexOf ("no", 1, s.Length);
1850 Assert.Fail ("#A1");
1851 } catch (ArgumentOutOfRangeException ex) {
1852 // Count must be positive and count must refer to a
1853 // location within the string/array/collection
1854 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1855 Assert.IsNull (ex.InnerException, "#A3");
1856 Assert.IsNotNull (ex.Message, "#A4");
1857 Assert.AreEqual ("count", ex.ParamName, "#A5");
1861 s.IndexOf ("no", 1, s.Length + 1);
1862 Assert.Fail ("#B1");
1863 } catch (ArgumentOutOfRangeException ex) {
1864 // Count must be positive and count must refer to a
1865 // location within the string/array/collection
1866 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1867 Assert.IsNull (ex.InnerException, "#B3");
1868 Assert.IsNotNull (ex.Message, "#B4");
1869 Assert.AreEqual ("count", ex.ParamName, "#B5");
1873 s.IndexOf ("no", 1, int.MaxValue);
1874 Assert.Fail ("#C1");
1875 } catch (ArgumentOutOfRangeException ex) {
1877 // Count must be positive and count must refer to a
1878 // location within the string/array/collection
1879 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1880 Assert.IsNull (ex.InnerException, "#C3");
1881 Assert.IsNotNull (ex.Message, "#C4");
1882 Assert.AreEqual ("count", ex.ParamName, "#C5");
1884 // Index was out of range. Must be non-negative and
1885 // less than the size of the collection
1886 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
1887 Assert.IsNull (ex.InnerException, "#C3");
1888 Assert.IsNotNull (ex.Message, "#C4");
1889 Assert.IsNotNull (ex.ParamName, "#C5");
1890 //Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
1895 [Test] // IndexOf (String, Int32, Int32)
1896 public void IndexOf7_StartIndex_Negative ()
1899 "Mono".IndexOf ("no", -1, 1);
1901 } catch (ArgumentOutOfRangeException ex) {
1902 // Index was out of range. Must be non-negative and
1903 // less than the size of the collection
1904 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1905 Assert.IsNull (ex.InnerException, "#3");
1906 Assert.IsNotNull (ex.Message, "#4");
1907 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1911 [Test] // IndexOf (String, Int32, Int32)
1912 public void IndexOf7_StartIndex_Overflow ()
1914 string s = "testing123456";
1917 s.IndexOf ("no", s.Length + 1, 1);
1918 Assert.Fail ("#A1");
1919 } catch (ArgumentOutOfRangeException ex) {
1920 // Index was out of range. Must be non-negative and
1921 // less than the size of the collection
1922 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1923 Assert.IsNull (ex.InnerException, "#A3");
1924 Assert.IsNotNull (ex.Message, "#A4");
1926 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
1928 Assert.IsNotNull (ex.ParamName, "#A5");
1929 //Assert.AreEqual ("count", ex.ParamName, "#A5");
1934 s.IndexOf ("no", int.MaxValue, 1);
1935 Assert.Fail ("#B1");
1936 } catch (ArgumentOutOfRangeException ex) {
1937 // Index was out of range. Must be non-negative and
1938 // less than the size of the collection
1939 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1940 Assert.IsNull (ex.InnerException, "#B3");
1941 Assert.IsNotNull (ex.Message, "#B4");
1942 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
1946 [Test] // IndexOf (String, Int32, Int32)
1947 public void IndexOf7_Value_Null ()
1950 "Mono".IndexOf ((string) null, 0, 1);
1952 } catch (ArgumentNullException ex) {
1953 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1954 Assert.IsNull (ex.InnerException, "#3");
1955 Assert.IsNotNull (ex.Message, "#4");
1957 Assert.AreEqual ("value", ex.ParamName, "#5");
1959 Assert.AreEqual ("string2", ex.ParamName, "#5");
1965 [Test] // IndexOf (String, Int32, StringComparison)
1966 public void IndexOf8_ComparisonType_Invalid ()
1969 "Mono".IndexOf (string.Empty, 1, (StringComparison) Int32.MinValue);
1971 } catch (ArgumentException ex) {
1972 // The string comparison type passed in is currently
1974 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1975 Assert.IsNull (ex.InnerException, "#3");
1976 Assert.IsNotNull (ex.Message, "#4");
1977 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
1981 [Test] // IndexOf (String, Int32, StringComparison)
1982 public void IndexOf8_StartIndex_Negative ()
1985 "Mono".IndexOf ("o", -1, StringComparison.Ordinal);
1987 } catch (ArgumentOutOfRangeException ex) {
1988 // Index was out of range. Must be non-negative and
1989 // less than the size of the collection
1990 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
1991 Assert.IsNull (ex.InnerException, "#3");
1992 Assert.IsNotNull (ex.Message, "#4");
1993 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
1997 [Test] // IndexOf (String, Int32, Int32, StringComparison)
1998 public void IndexOf9_ComparisonType_Invalid ()
2001 "Mono".IndexOf (string.Empty, 0, 1, (StringComparison) Int32.MinValue);
2003 } catch (ArgumentException ex) {
2004 // The string comparison type passed in is currently
2006 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2007 Assert.IsNull (ex.InnerException, "#3");
2008 Assert.IsNotNull (ex.Message, "#4");
2009 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
2013 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2014 public void IndexOf9_Count_Negative ()
2017 "Mono".IndexOf ("o", 1, -1, StringComparison.Ordinal);
2020 } catch (ArgumentOutOfRangeException ex) {
2021 // Count must be positive and count must refer to a
2022 // location within the string/array/collection
2023 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2024 Assert.IsNull (ex.InnerException, "#3");
2025 Assert.IsNotNull (ex.Message, "#4");
2026 Assert.AreEqual ("count", ex.ParamName, "#5");
2030 [Test] // IndexOf (String, Int32, Int32, StringComparison)
2031 public void IndexOf9_StartIndex_Negative ()
2034 "Mono".IndexOf ("o", -1, 0, StringComparison.Ordinal);
2036 } catch (ArgumentOutOfRangeException ex) {
2037 // Index was out of range. Must be non-negative and
2038 // less than the size of the collection
2039 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2040 Assert.IsNull (ex.InnerException, "#3");
2041 Assert.IsNotNull (ex.Message, "#4");
2042 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2048 public void IndexOfAny1 ()
2050 string s = "abcdefghijklmd";
2053 c = new char [] {'a', 'e', 'i', 'o', 'u'};
2054 Assert.AreEqual (0, s.IndexOfAny (c), "#1");
2055 c = new char [] { 'd', 'z' };
2056 Assert.AreEqual (3, s.IndexOfAny (c), "#1");
2057 c = new char [] { 'q', 'm', 'z' };
2058 Assert.AreEqual (12, s.IndexOfAny (c), "#2");
2060 Assert.AreEqual (-1, s.IndexOfAny (c), "#3");
2064 [Test] // IndexOfAny (Char [])
2065 public void IndexOfAny1_AnyOf_Null ()
2068 "mono".IndexOfAny ((char []) null);
2070 } catch (ArgumentNullException ex) {
2071 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2072 Assert.IsNull (ex.InnerException, "#3");
2073 Assert.IsNotNull (ex.Message, "#4");
2074 Assert.IsNull (ex.ParamName, "#5");
2078 [Test] // IndexOfAny (Char [], Int32)
2079 public void IndexOfAny2 ()
2081 string s = "abcdefghijklmd";
2084 c = new char [] { 'a', 'e', 'i', 'o', 'u' };
2085 Assert.AreEqual (0, s.IndexOfAny (c, 0), "#A1");
2086 Assert.AreEqual (4, s.IndexOfAny (c, 1), "#A1");
2087 Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#A2");
2088 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#A3");
2090 c = new char [] { 'd', 'z' };
2091 Assert.AreEqual (3, s.IndexOfAny (c, 0), "#B1");
2092 Assert.AreEqual (3, s.IndexOfAny (c, 3), "#B2");
2093 Assert.AreEqual (13, s.IndexOfAny (c, 4), "#B3");
2094 Assert.AreEqual (13, s.IndexOfAny (c, 9), "#B4");
2095 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#B5");
2096 Assert.AreEqual (13, s.IndexOfAny (c, s.Length - 1), "#B6");
2098 c = new char [] { 'q', 'm', 'z' };
2099 Assert.AreEqual (12, s.IndexOfAny (c, 0), "#C1");
2100 Assert.AreEqual (12, s.IndexOfAny (c, 4), "#C2");
2101 Assert.AreEqual (12, s.IndexOfAny (c, 12), "#C3");
2102 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#C4");
2105 Assert.AreEqual (-1, s.IndexOfAny (c, 0), "#D1");
2106 Assert.AreEqual (-1, s.IndexOfAny (c, 4), "#D2");
2107 Assert.AreEqual (-1, s.IndexOfAny (c, 9), "#D3");
2108 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length), "#D4");
2111 [Test] // IndexOfAny (Char [], Int32)
2112 public void IndexOfAny2_AnyOf_Null ()
2115 "mono".IndexOfAny ((char []) null, 0);
2117 } catch (ArgumentNullException ex) {
2118 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2119 Assert.IsNull (ex.InnerException, "#3");
2120 Assert.IsNotNull (ex.Message, "#4");
2121 Assert.IsNull (ex.ParamName, "#5");
2125 [Test] // IndexOfAny (Char [], Int32)
2126 public void IndexOfAny2_StartIndex_Negative ()
2128 string s = "abcdefghijklm";
2131 s.IndexOfAny (new char [1] { 'd' }, -1, 1);
2133 } catch (ArgumentOutOfRangeException ex) {
2134 // Specified argument was out of the range of valid
2136 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2137 Assert.IsNull (ex.InnerException, "#3");
2138 Assert.IsNotNull (ex.Message, "#4");
2139 Assert.IsNull (ex.ParamName, "#5");
2143 [Test] // IndexOfAny (Char [], Int32, Int32)
2144 public void IndexOfAny2_StartIndex_Overflow ()
2146 string s = "abcdefghijklm";
2149 s.IndexOfAny (new char [1] { 'd' }, s.Length + 1);
2151 } catch (ArgumentOutOfRangeException ex) {
2152 // Specified argument was out of the range of valid
2154 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2155 Assert.IsNull (ex.InnerException, "#3");
2156 Assert.IsNotNull (ex.Message, "#4");
2157 Assert.IsNull (ex.ParamName, "#5");
2161 [Test] // IndexOfAny (Char [], Int32, Int32)
2162 public void IndexOfAny3 ()
2164 string s = "abcdefghijklmd";
2167 c = new char [] { 'a', 'e', 'i', 'o', 'u' };
2168 Assert.AreEqual (0, s.IndexOfAny (c, 0, 2), "#A1");
2169 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#A2");
2170 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#A3");
2171 Assert.AreEqual (4, s.IndexOfAny (c, 1, 4), "#A3");
2172 Assert.AreEqual (4, s.IndexOfAny (c, 1, s.Length - 1), "#A4");
2174 c = new char [] { 'd', 'z' };
2175 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 2), "#B1");
2176 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 2), "#B2");
2177 Assert.AreEqual (3, s.IndexOfAny (c, 1, 3), "#B3");
2178 Assert.AreEqual (3, s.IndexOfAny (c, 0, s.Length), "#B4");
2179 Assert.AreEqual (3, s.IndexOfAny (c, 1, s.Length - 1), "#B5");
2180 Assert.AreEqual (-1, s.IndexOfAny (c, s.Length, 0), "#B6");
2182 c = new char [] { 'q', 'm', 'z' };
2183 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 10), "#C1");
2184 Assert.AreEqual (12, s.IndexOfAny (c, 10, 4), "#C2");
2185 Assert.AreEqual (-1, s.IndexOfAny (c, 1, 3), "#C3");
2186 Assert.AreEqual (12, s.IndexOfAny (c, 0, s.Length), "#C4");
2187 Assert.AreEqual (12, s.IndexOfAny (c, 1, s.Length - 1), "#C5");
2190 Assert.AreEqual (-1, s.IndexOfAny (c, 0, 3), "#D1");
2191 Assert.AreEqual (-1, s.IndexOfAny (c, 4, 9), "#D2");
2192 Assert.AreEqual (-1, s.IndexOfAny (c, 9, 5), "#D3");
2193 Assert.AreEqual (-1, s.IndexOfAny (c, 13, 1), "#D4");
2196 [Test] // IndexOfAny (Char [], Int32, Int32)
2197 public void IndexOfAny3_AnyOf_Null ()
2200 "mono".IndexOfAny ((char []) null, 0, 0);
2202 } catch (ArgumentNullException ex) {
2203 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2204 Assert.IsNull (ex.InnerException, "#3");
2205 Assert.IsNotNull (ex.Message, "#4");
2206 Assert.IsNull (ex.ParamName, "#5");
2210 [Test] // IndexOfAny (Char [], Int32, Int32)
2211 public void IndexOfAny3_Count_Negative ()
2214 "Mono".IndexOfAny (new char [1] { 'o' }, 1, -1);
2216 } catch (ArgumentOutOfRangeException ex) {
2217 // Count must be positive and count must refer to a
2218 // location within the string/array/collection
2219 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2220 Assert.IsNull (ex.InnerException, "#3");
2221 Assert.IsNotNull (ex.Message, "#4");
2222 Assert.AreEqual ("count", ex.ParamName, "#5");
2226 [Test] // IndexOfAny (Char [], Int32, Int32)
2227 public void IndexOfAny3_Length_Overflow ()
2229 string s = "abcdefghijklm";
2232 s.IndexOfAny (new char [1] { 'd' }, 1, s.Length);
2234 } catch (ArgumentOutOfRangeException ex) {
2235 // Count must be positive and count must refer to a
2236 // location within the string/array/collection
2237 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2238 Assert.IsNull (ex.InnerException, "#3");
2239 Assert.IsNotNull (ex.Message, "#4");
2240 Assert.AreEqual ("count", ex.ParamName, "#5");
2244 [Test] // IndexOfAny (Char [], Int32, Int32)
2245 public void IndexOfAny3_StartIndex_Negative ()
2248 "Mono".IndexOfAny (new char [1] { 'o' }, -1, 1);
2250 } catch (ArgumentOutOfRangeException ex) {
2251 // Specified argument was out of the range of valid
2253 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2254 Assert.IsNull (ex.InnerException, "#3");
2255 Assert.IsNotNull (ex.Message, "#4");
2256 Assert.IsNull (ex.ParamName, "#5");
2260 [Test] // IndexOfAny (Char [], Int32, Int32)
2261 public void IndexOfAny3_StartIndex_Overflow ()
2263 string s = "abcdefghijklm";
2266 s.IndexOfAny (new char [1] { 'o' }, s.Length + 1, 1);
2268 } catch (ArgumentOutOfRangeException ex) {
2269 // Specified argument was out of the range of valid
2271 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2272 Assert.IsNull (ex.InnerException, "#3");
2273 Assert.IsNotNull (ex.Message, "#4");
2274 Assert.IsNull (ex.ParamName, "#5");
2280 public void Contains ()
2282 Assert.IsTrue ("ABC".Contains (string.Empty));
2283 Assert.IsTrue ("ABC".Contains ("ABC"));
2284 Assert.IsTrue ("ABC".Contains ("AB"));
2285 Assert.IsTrue (!"ABC".Contains ("AD"));
2286 Assert.IsTrue (!"encyclopædia".Contains("encyclopaedia"));
2290 public void Contains_Value_Null ()
2293 "ABC".Contains (null);
2295 } catch (ArgumentNullException ex) {
2296 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2297 Assert.IsNull (ex.InnerException, "#3");
2298 Assert.IsNotNull (ex.Message, "#4");
2299 Assert.AreEqual ("value", ex.ParamName, "#5");
2304 public void IsNullOrEmpty ()
2306 Assert.IsTrue (String.IsNullOrEmpty (null));
2307 Assert.IsTrue (String.IsNullOrEmpty (String.Empty));
2308 Assert.IsTrue (String.IsNullOrEmpty (""));
2309 Assert.IsTrue (!String.IsNullOrEmpty ("A"));
2310 Assert.IsTrue (!String.IsNullOrEmpty (" "));
2311 Assert.IsTrue (!String.IsNullOrEmpty ("\t"));
2312 Assert.IsTrue (!String.IsNullOrEmpty ("\n"));
2317 public void TestInsert ()
2319 string s1 = "original";
2322 s1.Insert (0, null);
2323 Assert.Fail ("#A1");
2324 } catch (ArgumentNullException ex) {
2325 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2326 Assert.IsNull (ex.InnerException, "#A3");
2327 Assert.IsNotNull (ex.Message, "#A4");
2328 Assert.AreEqual ("value", ex.ParamName, "#A5");
2332 s1.Insert (s1.Length + 1, "Hi!");
2333 Assert.Fail ("#B1");
2334 } catch (ArgumentOutOfRangeException ex) {
2335 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
2336 Assert.IsNull (ex.InnerException, "#B3");
2337 Assert.IsNotNull (ex.Message, "#B4");
2338 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
2341 Assert.AreEqual ("Hi!original", s1.Insert (0, "Hi!"), "#C1");
2342 Assert.AreEqual ("originalHi!", s1.Insert (s1.Length, "Hi!"), "#C2");
2343 Assert.AreEqual ("origHi!inal", s1.Insert (4, "Hi!"), "#C3");
2347 public void Intern ()
2349 string s1 = "original";
2350 Assert.AreSame (s1, String.Intern (s1), "#A1");
2351 Assert.AreSame (String.Intern(s1), String.Intern(s1), "#A2");
2353 string s2 = "originally";
2354 Assert.AreSame (s2, String.Intern (s2), "#B1");
2355 Assert.IsTrue (String.Intern(s1) != String.Intern(s2), "#B2");
2357 string s3 = new DateTime (2000, 3, 7).ToString ();
2358 Assert.IsNull (String.IsInterned (s3), "#C1");
2359 Assert.AreSame (s3, String.Intern (s3), "#C2");
2360 Assert.AreSame (s3, String.IsInterned (s3), "#C3");
2361 Assert.AreSame (s3, String.IsInterned (new DateTime (2000, 3, 7).ToString ()), "#C4");
2362 Assert.AreSame (s3, String.Intern (new DateTime (2000, 3, 7).ToString ()), "#C5");
2366 public void Intern_Str_Null ()
2369 String.Intern (null);
2371 } catch (ArgumentNullException ex) {
2372 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2373 Assert.IsNull (ex.InnerException, "#3");
2374 Assert.IsNotNull (ex.Message, "#4");
2375 Assert.AreEqual ("str", ex.ParamName, "#5");
2380 public void IsInterned ()
2382 Assert.IsNull (String.IsInterned (new DateTime (2000, 3, 6).ToString ()), "#1");
2383 string s1 = "original";
2384 Assert.AreSame (s1, String.IsInterned (s1), "#2");
2388 public void IsInterned_Str_Null ()
2391 String.IsInterned (null);
2393 } catch (ArgumentNullException ex) {
2394 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2395 Assert.IsNull (ex.InnerException, "#3");
2396 Assert.IsNotNull (ex.Message, "#4");
2397 Assert.AreEqual ("str", ex.ParamName, "#5");
2402 public void TestJoin ()
2405 string s = String.Join(" ", null);
2406 Assert.Fail ("#A1");
2407 } catch (ArgumentNullException ex) {
2408 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2409 Assert.IsNull (ex.InnerException, "#A3");
2410 Assert.IsNotNull (ex.Message, "#A4");
2411 Assert.AreEqual ("value", ex.ParamName, "#A5");
2414 string[] chunks = {"this", "is", "a", "test"};
2415 Assert.AreEqual ("this is a test", String.Join(" ", chunks), "Basic join");
2416 Assert.AreEqual ("this.is.a.test", String.Join(".", chunks), "Basic join");
2418 Assert.AreEqual ("is a", String.Join(" ", chunks, 1, 2), "Subset join");
2419 Assert.AreEqual ("is.a", String.Join(".", chunks, 1, 2), "Subset join");
2420 Assert.AreEqual ("is a test", String.Join(" ", chunks, 1, 3), "Subset join");
2423 string s = String.Join(" ", chunks, 2, 3);
2424 Assert.Fail ("#C1");
2425 } catch (ArgumentOutOfRangeException ex) {
2426 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
2427 Assert.IsNull (ex.InnerException, "#C3");
2428 Assert.IsNotNull (ex.Message, "#C4");
2429 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
2434 public void Join_SeparatorNull ()
2436 string[] chunks = {"this", "is", "a", "test"};
2437 Assert.AreEqual ("thisisatest", String.Join (null, chunks), "SeparatorNull");
2441 public void Join_ValuesNull ()
2443 string[] chunks1 = {null, "is", "a", null};
2444 Assert.AreEqual (" is a ", String.Join (" ", chunks1), "SomeNull");
2446 string[] chunks2 = {null, "is", "a", null};
2447 Assert.AreEqual ("isa", String.Join (null, chunks2), "Some+Sep=Null");
2449 string[] chunks3 = {null, null, null, null};
2450 Assert.AreEqual (" ", String.Join (" ", chunks3), "AllValuesNull");
2454 public void Join_AllNull ()
2456 string[] chunks = {null, null, null};
2457 Assert.AreEqual (string.Empty, String.Join (null, chunks), "AllNull");
2461 public void Join_StartIndexNegative ()
2463 string[] values = { "Mo", "no" };
2465 String.Join ("o", values, -1, 1);
2467 } catch (ArgumentOutOfRangeException ex) {
2468 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2469 Assert.IsNull (ex.InnerException, "#3");
2470 Assert.IsNotNull (ex.Message, "#4");
2471 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2476 public void Join_StartIndexOverflow ()
2478 string[] values = { "Mo", "no" };
2480 String.Join ("o", values, Int32.MaxValue, 1);
2482 } catch (ArgumentOutOfRangeException ex) {
2483 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2484 Assert.IsNull (ex.InnerException, "#3");
2485 Assert.IsNotNull (ex.Message, "#4");
2486 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2491 public void Join_LengthNegative ()
2493 string[] values = { "Mo", "no" };
2495 String.Join ("o", values, 1, -1);
2497 } catch (ArgumentOutOfRangeException ex) {
2498 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2499 Assert.IsNull (ex.InnerException, "#3");
2500 Assert.IsNotNull (ex.Message, "#4");
2501 Assert.AreEqual ("count", ex.ParamName, "#5");
2506 public void Join_LengthOverflow ()
2508 string[] values = { "Mo", "no" };
2510 String.Join ("o", values, 1, Int32.MaxValue);
2512 } catch (ArgumentOutOfRangeException ex) {
2513 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2514 Assert.IsNull (ex.InnerException, "#3");
2515 Assert.IsNotNull (ex.Message, "#4");
2516 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2521 public void LastIndexOf ()
2523 string s1 = "original";
2526 s1.LastIndexOf ('q', -1);
2527 Assert.Fail ("#A1");
2528 } catch (ArgumentOutOfRangeException ex) {
2529 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
2530 Assert.IsNull (ex.InnerException, "#A3");
2531 Assert.IsNotNull (ex.Message, "#A4");
2532 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
2536 s1.LastIndexOf ('q', -1, 1);
2537 Assert.Fail ("#B1");
2538 } catch (ArgumentOutOfRangeException ex) {
2539 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
2540 Assert.IsNull (ex.InnerException, "#B3");
2541 Assert.IsNotNull (ex.Message, "#B4");
2542 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
2546 s1.LastIndexOf ("huh", s1.Length + 1);
2547 Assert.Fail ("#C1");
2548 } catch (ArgumentOutOfRangeException ex) {
2549 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
2550 Assert.IsNull (ex.InnerException, "#C3");
2551 Assert.IsNotNull (ex.Message, "#C4");
2552 Assert.AreEqual ("startIndex", ex.ParamName, "#C5");
2556 int i = s1.LastIndexOf ("huh", s1.Length + 1, 3);
2557 Assert.Fail ("#D1");
2558 } catch (ArgumentOutOfRangeException ex) {
2559 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
2560 Assert.IsNull (ex.InnerException, "#D3");
2561 Assert.IsNotNull (ex.Message, "#D4");
2562 Assert.AreEqual ("startIndex", ex.ParamName, "#D5");
2566 s1.LastIndexOf (null);
2567 Assert.Fail ("#E1");
2568 } catch (ArgumentNullException ex) {
2569 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#E2");
2570 Assert.IsNull (ex.InnerException, "#E3");
2571 Assert.IsNotNull (ex.Message, "#E4");
2573 Assert.AreEqual ("value", ex.ParamName, "#E5");
2575 Assert.AreEqual ("string2", ex.ParamName, "#E5");
2580 s1.LastIndexOf (null, 0);
2581 Assert.Fail ("#F1");
2582 } catch (ArgumentNullException ex) {
2583 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#F2");
2584 Assert.IsNull (ex.InnerException, "#F3");
2585 Assert.IsNotNull (ex.Message, "#F4");
2587 Assert.AreEqual ("value", ex.ParamName, "#F5");
2589 Assert.AreEqual ("string2", ex.ParamName, "#F5");
2594 s1.LastIndexOf (null, 0, 1);
2595 Assert.Fail ("#G1");
2596 } catch (ArgumentNullException ex) {
2597 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#G2");
2598 Assert.IsNull (ex.InnerException, "#G3");
2599 Assert.IsNotNull (ex.Message, "#G4");
2601 Assert.AreEqual ("value", ex.ParamName, "#G5");
2603 Assert.AreEqual ("string2", ex.ParamName, "#G5");
2607 Assert.AreEqual (1, s1.LastIndexOf('r'), "basic char index");
2608 Assert.AreEqual (4, s1.LastIndexOf('i'), "basic char index");
2609 Assert.AreEqual (-1, s1.LastIndexOf('q'), "basic char index - no");
2611 Assert.AreEqual (7, s1.LastIndexOf(string.Empty), "basic string index");
2612 Assert.AreEqual (1, s1.LastIndexOf("rig"), "basic string index");
2613 Assert.AreEqual (4, s1.LastIndexOf("i"), "basic string index");
2614 Assert.AreEqual (-1, s1.LastIndexOf("rag"), "basic string index - no");
2616 Assert.AreEqual (1, s1.LastIndexOf('r', s1.Length-1), "stepped char index");
2617 Assert.AreEqual (4, s1.LastIndexOf('i', s1.Length-1), "stepped char index");
2618 Assert.AreEqual (2, s1.LastIndexOf('i', 3), "stepped char index");
2619 Assert.AreEqual (-1, s1.LastIndexOf('i', 1), "stepped char index");
2621 Assert.AreEqual (1, s1.LastIndexOf('r', 1, 1), "stepped limited char index");
2622 Assert.AreEqual (-1, s1.LastIndexOf('r', 0, 1), "stepped limited char index");
2623 Assert.AreEqual (4, s1.LastIndexOf('i', 6, 3), "stepped limited char index");
2624 Assert.AreEqual (2, s1.LastIndexOf('i', 3, 3), "stepped limited char index");
2625 Assert.AreEqual (-1, s1.LastIndexOf('i', 1, 2), "stepped limited char index");
2627 s1 = "original original";
2628 Assert.AreEqual (9, s1.LastIndexOf("original", s1.Length), "stepped string index #1");
2629 Assert.AreEqual (0, s1.LastIndexOf("original", s1.Length-2), "stepped string index #2");
2630 Assert.AreEqual (-1, s1.LastIndexOf("original", s1.Length-11), "stepped string index #3");
2631 Assert.AreEqual (-1, s1.LastIndexOf("translator", 2), "stepped string index #4");
2632 Assert.AreEqual (0, string.Empty.LastIndexOf(string.Empty, 0), "stepped string index #5");
2634 Assert.AreEqual (-1, string.Empty.LastIndexOf("A", -1), "stepped string index #6");
2636 Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-1, 10), "stepped limited string index #1");
2637 Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length, 3), "stepped limited string index #2");
2638 Assert.AreEqual (10, s1.LastIndexOf("rig", s1.Length-2, 15), "stepped limited string index #3");
2639 Assert.AreEqual (-1, s1.LastIndexOf("rig", s1.Length-2, 3), "stepped limited string index #4");
2641 string s2 = "QBitArray::bitarr_data";
2642 Assert.AreEqual (9, s2.LastIndexOf ("::"), "bug #62160");
2644 string s3 = "test123";
2645 Assert.AreEqual (0, s3.LastIndexOf ("test123"), "bug #77412");
2650 [ExpectedException (typeof (ArgumentException))]
2651 public void LastIndexOf_StringComparison ()
2653 " ".LastIndexOf (string.Empty, 0, 1, (StringComparison)Int32.MinValue);
2657 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2658 public void LastIndexOfStringComparisonOrdinalRangeException1 ()
2660 "Mono".LastIndexOf ("no", 5, StringComparison.Ordinal);
2664 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2665 public void LastIndexOfStringComparisonOrdinalRangeException2 ()
2667 "Mono".LastIndexOf ("no", 1, 3, StringComparison.Ordinal);
2671 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2672 public void LastIndexOfStringComparisonOrdinalIgnoreCaseRangeException1 ()
2674 "Mono".LastIndexOf ("no", 5, StringComparison.OrdinalIgnoreCase);
2678 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2679 public void LastIndexOfStringComparisonOrdinalIgnoreCaseRangeException2 ()
2681 "Mono".LastIndexOf ("no", 1, 3, StringComparison.OrdinalIgnoreCase);
2685 public void LastIndexOfStringComparison ()
2687 string text = "testing123456";
2688 string text2 = "123";
2689 string text3 = "NG";
2691 Assert.AreEqual (7, text.LastIndexOf (text2, StringComparison.Ordinal), "#1-1");
2692 Assert.AreEqual (5, text.LastIndexOf (text3, StringComparison.OrdinalIgnoreCase), "#2-1");
2694 Assert.AreEqual (7, text.LastIndexOf (text2, 12, StringComparison.Ordinal), "#1-2");
2695 Assert.AreEqual (5, text.LastIndexOf (text3, 12, StringComparison.OrdinalIgnoreCase), "#2-2");
2697 Assert.AreEqual (-1, text.LastIndexOf (text2, 0, StringComparison.Ordinal), "#1-3");
2698 Assert.AreEqual (-1, text.LastIndexOf (text3, 0, StringComparison.OrdinalIgnoreCase), "#2-3");
2700 Assert.AreEqual (-1, text.LastIndexOf (text2, 6, StringComparison.Ordinal), "#1-4");
2701 Assert.AreEqual (5, text.LastIndexOf (text3, 6, StringComparison.OrdinalIgnoreCase), "#2-4");
2703 Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 3, StringComparison.Ordinal), "#1-5");
2704 Assert.AreEqual (5, text.LastIndexOf (text3, 7, 3, StringComparison.OrdinalIgnoreCase), "#2-5");
2706 Assert.AreEqual (-1, text.LastIndexOf (text2, 6, 0, StringComparison.Ordinal), "#1-6");
2707 Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 0, StringComparison.OrdinalIgnoreCase), "#2-6");
2709 Assert.AreEqual (-1, text.LastIndexOf (text2, 7, 1, StringComparison.Ordinal), "#1-7");
2710 Assert.AreEqual (-1, text.LastIndexOf (text3, 5, 1, StringComparison.OrdinalIgnoreCase), "#2-7");
2712 Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.Ordinal), "#3-1");
2713 Assert.AreEqual (0, text.LastIndexOf (text4, 0, StringComparison.OrdinalIgnoreCase), "#3-2");
2715 Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.Ordinal), "#4-1");
2716 Assert.AreEqual (3, text.LastIndexOf (text4, 13, StringComparison.OrdinalIgnoreCase), "#4-2");
2718 Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.Ordinal), "#4-1");
2719 Assert.AreEqual (3, text.LastIndexOf (text4, 13, 14, StringComparison.OrdinalIgnoreCase), "#4-2");
2721 Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.Ordinal), "#5-1");
2722 Assert.AreEqual (0, text.LastIndexOf (text4, 1, 2, StringComparison.OrdinalIgnoreCase), "#5-2");
2724 Assert.AreEqual (-1, "".LastIndexOf ("FOO", StringComparison.Ordinal));
2725 Assert.AreEqual (0, "".LastIndexOf ("", StringComparison.Ordinal));
2729 public void LastIndexOfStringComparisonOrdinal ()
2731 string text = "testing123456";
2732 Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.Ordinal), "#1");
2733 Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.Ordinal), "#2");
2734 Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.Ordinal), "#3");
2735 Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.Ordinal), "#4");
2736 Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.Ordinal), "#5");
2737 Assert.AreEqual (-1, text.LastIndexOf ("S", StringComparison.Ordinal), "#6");
2741 public void LastIndexOfStringComparisonOrdinalIgnoreCase ()
2743 string text = "testing123456";
2744 Assert.AreEqual (10, text.LastIndexOf ("456", StringComparison.OrdinalIgnoreCase), "#1");
2745 Assert.AreEqual (-1, text.LastIndexOf ("4567", StringComparison.OrdinalIgnoreCase), "#2");
2746 Assert.AreEqual (0, text.LastIndexOf ("te", StringComparison.OrdinalIgnoreCase), "#3");
2747 Assert.AreEqual (2, text.LastIndexOf ("s", StringComparison.OrdinalIgnoreCase), "#4");
2748 Assert.AreEqual (-1, text.LastIndexOf ("ates", StringComparison.OrdinalIgnoreCase), "#5");
2749 Assert.AreEqual (2, text.LastIndexOf ("S", StringComparison.OrdinalIgnoreCase), "#6");
2754 public void LastIndexOf_Char_StartIndexStringLength ()
2758 s.LastIndexOf ('n', s.Length, 1);
2760 } catch (ArgumentOutOfRangeException ex) {
2761 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2762 Assert.IsNull (ex.InnerException, "#3");
2763 Assert.IsNotNull (ex.Message, "#4");
2764 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2766 // this works for string but not for a char
2770 public void LastIndexOf_Char_StartIndexOverflow ()
2773 "Mono".LastIndexOf ('o', Int32.MaxValue, 1);
2775 } catch (ArgumentOutOfRangeException ex) {
2776 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2777 Assert.IsNull (ex.InnerException, "#3");
2778 Assert.IsNotNull (ex.Message, "#4");
2779 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2784 public void LastIndexOf_Char_LengthOverflow ()
2787 "Mono".LastIndexOf ('o', 1, Int32.MaxValue);
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 ("count", ex.ParamName, "#5");
2798 public void LastIndexOf_String_StartIndexStringLength ()
2801 Assert.AreEqual (-1, s.LastIndexOf ("n", s.Length, 1));
2802 // this works for string but not for a char
2806 public void LastIndexOf_String_StartIndexStringLength_Plus1 ()
2810 s.LastIndexOf ("n", s.Length + 1, 1);
2812 } catch (ArgumentOutOfRangeException ex) {
2813 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2814 Assert.IsNull (ex.InnerException, "#3");
2815 Assert.IsNotNull (ex.Message, "#4");
2816 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2821 public void LastIndexOf_String_StartIndexOverflow ()
2824 "Mono".LastIndexOf ("no", Int32.MaxValue, 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_LengthOverflow ()
2838 "Mono".LastIndexOf ("no", 1, Int32.MaxValue);
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 ("count", ex.ParamName, "#5");
2849 public void LastIndexOfAny ()
2851 string s1 = ".bcdefghijklm";
2854 s1.LastIndexOfAny (null);
2855 Assert.Fail ("#A1");
2856 } catch (ArgumentNullException ex) {
2857 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
2858 Assert.IsNull (ex.InnerException, "#A3");
2859 Assert.IsNotNull (ex.Message, "#A4");
2860 Assert.IsNull (ex.ParamName, "#A5");
2864 s1.LastIndexOfAny (null, s1.Length);
2865 Assert.Fail ("#B1");
2866 } catch (ArgumentNullException ex) {
2867 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
2868 Assert.IsNull (ex.InnerException, "#B3");
2869 Assert.IsNotNull (ex.Message, "#B4");
2870 Assert.IsNull (ex.ParamName, "#B5");
2874 s1.LastIndexOfAny (null, s1.Length, 1);
2875 Assert.Fail ("#C1");
2876 } catch (ArgumentNullException ex) {
2877 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
2878 Assert.IsNull (ex.InnerException, "#C3");
2879 Assert.IsNotNull (ex.Message, "#C4");
2880 Assert.IsNull (ex.ParamName, "#C5");
2883 char[] c1 = {'a', 'e', 'i', 'o', 'u'};
2884 Assert.AreEqual (8, s1.LastIndexOfAny (c1), "#D1");
2885 Assert.AreEqual (4, s1.LastIndexOfAny (c1, 7), "#D2");
2886 Assert.AreEqual (-1, s1.LastIndexOfAny (c1, 3), "#D3");
2887 Assert.AreEqual (4, s1.LastIndexOfAny (c1, s1.Length - 6, 4), "#D4");
2888 Assert.AreEqual (-1, s1.LastIndexOfAny (c1, s1.Length - 6, 3), "#D5");
2891 s1.LastIndexOfAny (c1, -1);
2892 Assert.Fail ("#E1");
2893 } catch (ArgumentOutOfRangeException ex) {
2894 // Index was out of range. Must be non-negative and
2895 // less than the size of the collection
2896 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2");
2897 Assert.IsNull (ex.InnerException, "#E3");
2898 Assert.IsNotNull (ex.Message, "#E4");
2899 Assert.AreEqual ("startIndex", ex.ParamName, "#E5");
2903 s1.LastIndexOfAny (c1, -1, 1);
2904 Assert.Fail ("#F1");
2905 } catch (ArgumentOutOfRangeException ex) {
2906 // Index was out of range. Must be non-negative and
2907 // less than the size of the collection
2908 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#F2");
2909 Assert.IsNull (ex.InnerException, "#F3");
2910 Assert.IsNotNull (ex.Message, "#F4");
2911 Assert.AreEqual ("startIndex", ex.ParamName, "#F5");
2916 public void LastIndexOfAny_Length_Overflow ()
2919 "Mono".LastIndexOfAny (new char [1] { 'o' }, 1, Int32.MaxValue);
2921 } catch (ArgumentOutOfRangeException ex) {
2922 // Count must be positive and count must refer to a
2923 // location within the string/array/collection
2924 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2925 Assert.IsNull (ex.InnerException, "#3");
2926 Assert.IsNotNull (ex.Message, "#4");
2927 Assert.AreEqual ("count", ex.ParamName, "#5");
2932 public void LastIndexOfAny_StartIndex_Overflow ()
2935 "Mono".LastIndexOfAny (new char [1] { 'o' }, Int32.MaxValue, 1);
2937 } catch (ArgumentOutOfRangeException ex) {
2938 // Index was out of range. Must be non-negative and
2939 // less than the size of the collection
2940 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2941 Assert.IsNull (ex.InnerException, "#3");
2942 Assert.IsNotNull (ex.Message, "#4");
2943 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
2947 [Test] // PadLeft (Int32)
2948 public void PadLeft1 ()
2953 result = s1.PadLeft (0);
2954 Assert.AreSame (s1, result, "#A");
2956 result = s1.PadLeft (s1.Length - 1);
2957 Assert.AreSame (s1, result, "#B");
2959 result = s1.PadLeft (s1.Length);
2960 Assert.AreEqual (s1, result, "#C1");
2961 Assert.IsTrue (!object.ReferenceEquals (s1, result), "#C2");
2963 result = s1.PadLeft (s1.Length + 1);
2964 Assert.AreEqual (" Hi!", result, "#D");
2967 [Test] // PadLeft (Int32)
2968 public void PadLeft1_TotalWidth_Negative ()
2971 "Mono".PadLeft (-1);
2973 } catch (ArgumentOutOfRangeException ex) {
2974 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
2975 Assert.IsNull (ex.InnerException, "#3");
2976 Assert.IsNotNull (ex.Message, "#4");
2977 Assert.AreEqual ("totalWidth", ex.ParamName, "#5");
2981 [Test] // PadRight (Int32)
2982 public void PadRight1 ()
2987 result = s1.PadRight (0);
2988 Assert.AreSame (s1, result, "#A");
2990 result = s1.PadRight (s1.Length - 1);
2991 Assert.AreSame (s1, result, "#B");
2993 result = s1.PadRight (s1.Length);
2994 Assert.AreEqual (s1, result, "#C1");
2995 Assert.IsTrue (!object.ReferenceEquals (s1, result), "#C2");
2997 result = s1.PadRight (s1.Length + 1);
2998 Assert.AreEqual ("Hi! ", result, "#D");
3001 [Test] // PadRight1 (Int32)
3002 public void PadRight1_TotalWidth_Negative ()
3005 "Mono".PadRight (-1);
3007 } catch (ArgumentOutOfRangeException ex) {
3008 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3009 Assert.IsNull (ex.InnerException, "#3");
3010 Assert.IsNotNull (ex.Message, "#4");
3011 Assert.AreEqual ("totalWidth", ex.ParamName, "#5");
3015 [Test] // Remove (Int32, Int32)
3016 public void Remove2 ()
3018 string s1 = "original";
3022 Assert.Fail ("#A1");
3023 } catch (ArgumentOutOfRangeException ex) {
3024 // StartIndex cannot be less than zero
3025 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3026 Assert.IsNull (ex.InnerException, "#A3");
3027 Assert.IsNotNull (ex.Message, "#A4");
3028 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3033 Assert.Fail ("#B1");
3034 } catch (ArgumentOutOfRangeException ex) {
3035 // Count cannot be less than zero
3036 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3037 Assert.IsNull (ex.InnerException, "#B3");
3038 Assert.IsNotNull (ex.Message, "#B4");
3039 Assert.AreEqual ("count", ex.ParamName, "#B5");
3043 s1.Remove (s1.Length, s1.Length);
3044 Assert.Fail ("#C1");
3045 } catch (ArgumentOutOfRangeException ex) {
3046 // Index and count must refer to a location within the
3048 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
3049 Assert.IsNull (ex.InnerException, "#C3");
3050 Assert.IsNotNull (ex.Message, "#C4");
3051 Assert.AreEqual ("count", ex.ParamName, "#C5");
3054 Assert.AreEqual ("oinal", s1.Remove(1, 3), "#D1");
3055 Assert.AreEqual (s1, s1.Remove (0, 0), "#D2");
3056 Assert.IsTrue (!object.ReferenceEquals (s1, s1.Remove (0, 0)), "#D3");
3057 Assert.AreEqual ("riginal", s1.Remove (0, 1), "#D4");
3058 Assert.AreEqual ("origina", s1.Remove (7, 1), "#D5");
3061 [Test] // Remove (Int32, Int32)
3062 public void Remove2_Length_Overflow ()
3065 "Mono".Remove (1, Int32.MaxValue);
3067 } catch (ArgumentOutOfRangeException ex) {
3068 // Index and count must refer to a location within the
3070 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3071 Assert.IsNull (ex.InnerException, "#3");
3072 Assert.IsNotNull (ex.Message, "#4");
3073 Assert.AreEqual ("count", ex.ParamName, "#5");
3077 [Test] // Remove (Int32, Int32)
3078 public void Remove2_StartIndex_Overflow ()
3081 "Mono".Remove (Int32.MaxValue, 1);
3083 } catch (ArgumentOutOfRangeException ex) {
3084 // Index and count must refer to a location within the
3086 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3087 Assert.IsNull (ex.InnerException, "#3");
3088 Assert.IsNotNull (ex.Message, "#4");
3089 Assert.AreEqual ("count", ex.ParamName, "#5");
3094 [Test] // Remove (Int32)
3095 public void Remove1_StartIndex_Negative ()
3100 } catch (ArgumentOutOfRangeException ex) {
3101 // StartIndex cannot be less than zero
3102 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3103 Assert.IsNull (ex.InnerException, "#3");
3104 Assert.IsNotNull (ex.Message, "#4");
3105 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3109 [Test] // Remove (Int32)
3110 public void Remove1_StartIndex_Overflow ()
3115 } catch (ArgumentOutOfRangeException ex) {
3116 // startIndex must be less than length of string
3117 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3118 Assert.IsNull (ex.InnerException, "#3");
3119 Assert.IsNotNull (ex.Message, "#4");
3120 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3124 [Test] // Remove (Int32)
3125 public void Remove1 ()
3129 Assert.AreEqual ("AB", s.Remove (2), "#1");
3130 Assert.AreEqual (string.Empty, s.Remove (0), "#2");
3131 Assert.AreEqual ("A", s.Remove (1), "#3");
3136 public void Replace()
3138 string s1 = "original";
3140 Assert.AreEqual (s1, s1.Replace('q', 's'), "non-hit char");
3141 Assert.AreEqual ("oxiginal", s1.Replace('r', 'x'), "single char");
3142 Assert.AreEqual ("orxgxnal", s1.Replace('i', 'x'), "double char");
3144 bool errorThrown = false;
3146 string s = s1.Replace(null, "feh");
3147 } catch (ArgumentNullException) {
3150 Assert.IsTrue (errorThrown, "should get null arg exception");
3152 Assert.AreEqual ("ornal", s1.Replace("igi", null), "replace as remove");
3153 Assert.AreEqual (s1, s1.Replace("spam", "eggs"), "non-hit string");
3154 Assert.AreEqual ("orirumal", s1.Replace("gin", "rum"), "single string");
3155 Assert.AreEqual ("oreigeinal", s1.Replace("i", "ei"), "double string");
3157 Assert.AreEqual ("ooriginal", s1.Replace("o", "oo"), "start");
3158 Assert.AreEqual ("originall", s1.Replace("l", "ll"), "end");
3160 Assert.AreEqual ("riginal", s1.Replace("o", string.Empty), "start empty");
3161 Assert.AreEqual ("origina", s1.Replace("l", string.Empty), "end empty");
3163 Assert.AreEqual ("original", s1.Replace("original2", "original3"), "replace bigger that original");
3165 Assert.AreEqual (":!:", "::".Replace ("::", ":!:"), "result longer");
3167 // Test overlapping matches (bug #54988)
3168 string s2 = "...aaaaaaa.bbbbbbbbb,............ccccccc.u...";
3169 Assert.AreEqual (s2.Replace("..", "."), "..aaaaaaa.bbbbbbbbb,......ccccccc.u..");
3171 // Test replacing null characters (bug #67395)
3172 #if !TARGET_JVM //bug #7276
3173 Assert.AreEqual ("is this ok ?", "is \0 ok ?".Replace ("\0", "this"), "should not strip content after nullchar");
3178 public void ReplaceStringBeginEndTest ()
3180 string s1 = "original";
3182 Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1");
3183 Assert.AreEqual ("origina", s1.Replace ("l", ""), "#2");
3184 Assert.AreEqual ("ariginal", s1.Replace ("o", "a"), "#3");
3185 Assert.AreEqual ("originaa", s1.Replace ("l", "a"), "#4");
3186 Assert.AreEqual ("aariginal", s1.Replace ("o", "aa"), "#5");
3187 Assert.AreEqual ("originaaa", s1.Replace ("l", "aa"), "#6");
3188 Assert.AreEqual ("original", s1.Replace ("o", "o"), "#7");
3189 Assert.AreEqual ("original", s1.Replace ("l", "l"), "#8");
3190 Assert.AreEqual ("original", s1.Replace ("original", "original"), "#9");
3191 Assert.AreEqual ("", s1.Replace ("original", ""), "#10");
3195 public void ReplaceStringBeginEndTestFallback ()
3197 string prev = new String ('o', 300);
3198 string s1 = prev + "riginal";
3200 Assert.AreEqual ("riginal", s1.Replace ("o", ""), "#1");
3201 Assert.AreEqual (prev + "rigina", s1.Replace ("l", ""), "#2");
3202 Assert.AreEqual (new String ('a', 300) + "riginal", s1.Replace ("o", "a"), "#3");
3203 Assert.AreEqual (prev + "riginaa", s1.Replace ("l", "a"), "#4");
3204 Assert.AreEqual (new String ('a', 600) + "riginal", s1.Replace ("o", "aa"), "#5");
3205 Assert.AreEqual (prev + "riginaaa", s1.Replace ("l", "aa"), "#6");
3206 Assert.AreEqual (s1, s1.Replace ("o", "o"), "#7");
3207 Assert.AreEqual (s1, s1.Replace ("l", "l"), "#8");
3208 Assert.AreEqual (s1, s1.Replace (s1, s1), "#9");
3209 Assert.AreEqual ("", s1.Replace (prev + "riginal", ""), "#10");
3213 public void ReplaceStringOffByOne ()
3215 Assert.AreEqual ("", new String ('o', 199).Replace ("o", ""), "#-1");
3216 Assert.AreEqual ("", new String ('o', 200).Replace ("o", ""), "#0");
3217 Assert.AreEqual ("", new String ('o', 201).Replace ("o", ""), "#+1");
3221 public void ReplaceStringCultureTests ()
3223 // LAMESPEC: According to MSDN Replace with String parameter is culture-senstive.
3224 // However this does not currently seem to be the case. Otherwise following code should
3225 // produce "check" instead of "AE"
3227 CultureInfo old = Thread.CurrentThread.CurrentCulture;
3228 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3229 Assert.AreEqual ("AE", "AE".Replace ("\u00C6", "check"), "#1");
3230 Thread.CurrentThread.CurrentCulture = old;
3233 [Test] // StartsWith (String)
3234 public void StartsWith1 ()
3236 string s1 = "original";
3238 Assert.IsTrue (s1.StartsWith ("o"), "#1");
3239 Assert.IsTrue (s1.StartsWith ("orig"), "#2");
3240 Assert.IsTrue (!s1.StartsWith ("rig"), "#3");
3241 Assert.IsTrue (s1.StartsWith (String.Empty), "#4");
3242 Assert.IsTrue (String.Empty.StartsWith (String.Empty), "#5");
3243 Assert.IsTrue (!String.Empty.StartsWith ("rig"), "#6");
3246 [Test] // StartsWith (String)
3247 public void StartsWith1_Value_Null ()
3250 "A".StartsWith (null);
3252 } catch (ArgumentNullException ex) {
3253 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3254 Assert.IsNull (ex.InnerException, "#3");
3255 Assert.IsNotNull (ex.Message, "#4");
3256 Assert.AreEqual ("value", ex.ParamName, "#5");
3261 [Test] // StartsWith (String, StringComparison)
3262 public void StartsWith2_ComparisonType_Invalid ()
3265 "ABC".StartsWith ("A", (StringComparison) 80);
3267 } catch (ArgumentException ex) {
3268 // The string comparison type passed in is currently
3270 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3271 Assert.IsNull (ex.InnerException, "#3");
3272 Assert.IsNotNull (ex.Message, "#4");
3273 Assert.AreEqual ("comparisonType", ex.ParamName, "#5");
3277 [Test] // StartsWith (String, StringComparison)
3278 public void StartsWith2_Value_Null ()
3281 "A".StartsWith (null, StringComparison.CurrentCulture);
3283 } catch (ArgumentNullException ex) {
3284 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3285 Assert.IsNull (ex.InnerException, "#3");
3286 Assert.IsNotNull (ex.Message, "#4");
3287 Assert.AreEqual ("value", ex.ParamName, "#5");
3291 [Test] // StartsWith (String, Boolean, CultureInfo)
3292 public void StartsWith3_Culture_Null ()
3294 // This should not crash
3297 s.StartsWith ("this", true, null);
3301 [Test] // SubString (Int32)
3302 public void Substring1 ()
3304 string s = "original";
3306 Assert.AreEqual ("inal", s.Substring (4), "#1");
3307 Assert.AreEqual (string.Empty, s.Substring (s.Length), "#2");
3309 Assert.AreSame (s, s.Substring (0), "#3");
3311 Assert.AreEqual (s, s.Substring (0), "#3a");
3312 Assert.IsTrue (!object.ReferenceEquals (s, s.Substring (0)), "#3b");
3316 [Test] // SubString (Int32)
3317 public void SubString1_StartIndex_Negative ()
3319 string s = "original";
3324 } catch (ArgumentOutOfRangeException ex) {
3325 // StartIndex cannot be less than zero
3326 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3327 Assert.IsNull (ex.InnerException, "#3");
3328 Assert.IsNotNull (ex.Message, "#4");
3329 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3333 [Test] // SubString (Int32)
3334 public void SubString1_StartIndex_Overflow ()
3336 string s = "original";
3339 s.Substring (s.Length + 1);
3341 } catch (ArgumentOutOfRangeException ex) {
3342 // startIndex cannot be larger than length of string
3343 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3344 Assert.IsNull (ex.InnerException, "#3");
3345 Assert.IsNotNull (ex.Message, "#4");
3347 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3349 Assert.AreEqual ("length", ex.ParamName, "#5");
3354 [Test] // SubString (Int32, Int32)
3355 public void Substring2 ()
3357 string s = "original";
3359 Assert.AreEqual ("igin", s.Substring (2, 4), "#1");
3360 Assert.AreEqual (string.Empty, s.Substring (s.Length, 0), "#2");
3361 Assert.AreEqual ("origina", s.Substring (0, s.Length - 1), "#3");
3362 Assert.AreEqual (s, s.Substring (0, s.Length), "#4");
3364 Assert.AreSame (s, s.Substring (0, s.Length), "#5");
3366 Assert.IsTrue (!object.ReferenceEquals (s, s.Substring (0, s.Length)), "#5");
3370 [Test] // SubString (Int32, Int32)
3371 public void SubString2_Length_Negative ()
3373 string s = "original";
3376 s.Substring (1, -1);
3378 } catch (ArgumentOutOfRangeException ex) {
3379 // Length cannot be less than zero
3380 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3381 Assert.IsNull (ex.InnerException, "#3");
3382 Assert.IsNotNull (ex.Message, "#4");
3383 Assert.AreEqual ("length", ex.ParamName, "#5");
3387 [Test] // SubString (Int32, Int32)
3388 public void Substring2_Length_Overflow ()
3390 string s = "original";
3393 s.Substring (s.Length, 1);
3394 Assert.Fail ("#A1");
3395 } catch (ArgumentOutOfRangeException ex) {
3396 // Index and length must refer to a location within
3398 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3399 Assert.IsNull (ex.InnerException, "#A3");
3400 Assert.IsNotNull (ex.Message, "#A4");
3401 Assert.AreEqual ("length", ex.ParamName, "#A5");
3405 s.Substring (1, s.Length);
3406 Assert.Fail ("#B1");
3407 } catch (ArgumentOutOfRangeException ex) {
3408 // Index and length must refer to a location within
3410 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3411 Assert.IsNull (ex.InnerException, "#B3");
3412 Assert.IsNotNull (ex.Message, "#B4");
3413 Assert.AreEqual ("length", ex.ParamName, "#B5");
3417 s.Substring (1, Int32.MaxValue);
3418 Assert.Fail ("#C1");
3419 } catch (ArgumentOutOfRangeException ex) {
3420 // Index and length must refer to a location within
3422 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
3423 Assert.IsNull (ex.InnerException, "#C3");
3424 Assert.IsNotNull (ex.Message, "#C4");
3425 Assert.AreEqual ("length", ex.ParamName, "#C5");
3429 [Test] // SubString (Int32, Int32)
3430 public void SubString2_StartIndex_Negative ()
3432 string s = "original";
3435 s.Substring (-1, 1);
3437 } catch (ArgumentOutOfRangeException ex) {
3438 // StartIndex cannot be less than zero
3439 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3440 Assert.IsNull (ex.InnerException, "#3");
3441 Assert.IsNotNull (ex.Message, "#4");
3442 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3446 [Test] // SubString (Int32, Int32)
3447 public void Substring2_StartIndex_Overflow ()
3449 string s = "original";
3452 s.Substring (s.Length + 1, 0);
3453 Assert.Fail ("#A1");
3454 } catch (ArgumentOutOfRangeException ex) {
3455 // startIndex cannot be larger than length of string
3456 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3457 Assert.IsNull (ex.InnerException, "#A3");
3458 Assert.IsNotNull (ex.Message, "#A4");
3460 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3462 Assert.AreEqual ("length", ex.ParamName, "#A5");
3467 "Mono".Substring (Int32.MaxValue, 1);
3468 Assert.Fail ("#B1");
3469 } catch (ArgumentOutOfRangeException ex) {
3470 // startIndex cannot be larger than length of string
3471 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
3472 Assert.IsNull (ex.InnerException, "#B3");
3473 Assert.IsNotNull (ex.Message, "#B4");
3475 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3477 Assert.AreEqual ("length", ex.ParamName, "#B5");
3483 public void ToCharArray ()
3485 const string s = "original";
3488 c = s.ToCharArray ();
3489 Assert.AreEqual (s.Length, c.Length, "#A1");
3490 Assert.AreEqual (s, new String (c), "#A2");
3492 c = s.ToCharArray (0, s.Length);
3493 Assert.AreEqual (s.Length, c.Length, "#B1");
3494 Assert.AreEqual (s, new String (c), "#B2");
3496 c = s.ToCharArray (1, s.Length - 1);
3497 Assert.AreEqual (7, c.Length, "#C1");
3498 Assert.AreEqual ("riginal", new String (c), "#C2");
3500 c = s.ToCharArray (0, 3);
3501 Assert.AreEqual (3, c.Length, "#D1");
3502 Assert.AreEqual ("ori", new String (c), "#D2");
3504 c = s.ToCharArray (2, 0);
3505 Assert.AreEqual (0, c.Length, "#E1");
3506 Assert.AreEqual (string.Empty, new String (c), "#E2");
3508 c = s.ToCharArray (3, 2);
3509 Assert.AreEqual (2, c.Length, "#F1");
3510 Assert.AreEqual ("gi", new String (c), "#F2");
3512 c = s.ToCharArray (s.Length, 0);
3513 Assert.AreEqual (0, c.Length, "#G1");
3514 Assert.AreEqual (string.Empty, new String (c), "#G2");
3518 public void ToCharArray_Length_Negative ()
3520 const string s = "original";
3523 s.ToCharArray (1, -1);
3525 } catch (ArgumentOutOfRangeException ex) {
3526 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3527 Assert.IsNull (ex.InnerException, "#3");
3528 Assert.IsNotNull (ex.Message, "#4");
3529 Assert.AreEqual ("length", ex.ParamName, "#5");
3534 public void ToCharArray_Length_Overflow ()
3536 const string s = "original";
3539 s.ToCharArray (1, s.Length);
3540 Assert.Fail ("#A1");
3541 } catch (ArgumentOutOfRangeException ex) {
3542 // Index was out of range. Must be non-negative and
3543 // less than the size of the collection
3544 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3545 Assert.IsNull (ex.InnerException, "#A3");
3546 Assert.IsNotNull (ex.Message, "#A4");
3547 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3551 s.ToCharArray (1, Int32.MaxValue);
3552 Assert.Fail ("#B1");
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 (), "#B2");
3557 Assert.IsNull (ex.InnerException, "#B3");
3558 Assert.IsNotNull (ex.Message, "#B4");
3559 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3564 public void ToCharArray_StartIndex_Negative ()
3566 const string s = "original";
3569 s.ToCharArray (-1, 1);
3571 } catch (ArgumentOutOfRangeException ex) {
3572 // Index was out of range. Must be non-negative and
3573 // less than the size of the collection
3574 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3575 Assert.IsNull (ex.InnerException, "#3");
3576 Assert.IsNotNull (ex.Message, "#4");
3577 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3582 public void ToCharArray_StartIndex_Overflow ()
3584 const string s = "original";
3587 s.ToCharArray (s.Length, 1);
3588 Assert.Fail ("#A1");
3589 } catch (ArgumentOutOfRangeException ex) {
3590 // Index was out of range. Must be non-negative and
3591 // less than the size of the collection
3592 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
3593 Assert.IsNull (ex.InnerException, "#A3");
3594 Assert.IsNotNull (ex.Message, "#A4");
3595 Assert.AreEqual ("startIndex", ex.ParamName, "#A5");
3599 s.ToCharArray (Int32.MaxValue, 1);
3600 Assert.Fail ("#B1");
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 (), "#B2");
3605 Assert.IsNull (ex.InnerException, "#B3");
3606 Assert.IsNotNull (ex.Message, "#B4");
3607 Assert.AreEqual ("startIndex", ex.ParamName, "#B5");
3611 [Test] // ToLower ()
3612 public void ToLower1 ()
3614 string s = "OrIgInAli";
3616 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3618 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower(), "#1");
3620 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3622 Assert.AreEqual ("originali", s.ToLower (), "#2");
3625 [Test] // ToLower (CultureInfo)
3626 public void ToLower2 ()
3628 string s = "OrIgInAli";
3630 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3632 Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#A1");
3633 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#A2");
3634 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#A3");
3635 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#A4");
3637 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3639 Assert.AreEqual ("originali", s.ToLower (new CultureInfo ("en-US")), "#B1");
3640 Assert.AreEqual ("\u006f\u0072\u0131\u0067\u0131\u006e\u0061\u006c\u0069", s.ToLower (new CultureInfo ("tr-TR")), "#B2");
3641 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("en-US")), "#B3");
3642 Assert.AreEqual (string.Empty, string.Empty.ToLower (new CultureInfo ("tr-TR")), "#B4");
3645 [Test] // ToLower (CultureInfo)
3646 public void ToLower2_Culture_Null ()
3648 string s = "OrIgInAl";
3651 s.ToLower ((CultureInfo) null);
3652 Assert.Fail ("#A1");
3653 } catch (ArgumentNullException ex) {
3654 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
3655 Assert.IsNull (ex.InnerException, "#A3");
3656 Assert.IsNotNull (ex.Message, "#A4");
3657 Assert.AreEqual ("culture", ex.ParamName, "#A5");
3661 string.Empty.ToLower ((CultureInfo) null);
3662 Assert.Fail ("#B1");
3663 } catch (ArgumentNullException ex) {
3664 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
3665 Assert.IsNull (ex.InnerException, "#B3");
3666 Assert.IsNotNull (ex.Message, "#B4");
3667 Assert.AreEqual ("culture", ex.ParamName, "#B5");
3672 public void TestToString ()
3674 string s1 = "OrIgInAli";
3675 Assert.AreEqual (s1, s1.ToString(), "ToString failed!");
3678 [Test] // ToUpper ()
3679 public void ToUpper1 ()
3681 string s = "OrIgInAli";
3683 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3685 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (), "#1");
3687 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3689 Assert.AreEqual ("ORIGINALI", s.ToUpper (), "#2");
3692 [Test] // ToUpper (CultureInfo)
3693 public void ToUpper2 ()
3695 string s = "OrIgInAli";
3697 Thread.CurrentThread.CurrentCulture = new CultureInfo ("tr-TR");
3699 Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#A1");
3700 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#A2");
3701 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#A3");
3702 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#A4");
3704 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
3706 Assert.AreEqual ("ORIGINALI", s.ToUpper (new CultureInfo ("en-US")), "#B1");
3707 Assert.AreEqual ("ORIGINAL\u0130", s.ToUpper (new CultureInfo ("tr-TR")), "#B2");
3708 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("en-US")), "#B3");
3709 Assert.AreEqual (string.Empty, string.Empty.ToUpper (new CultureInfo ("tr-TR")), "#B4");
3712 [Test] // ToUpper (CultureInfo)
3713 public void ToUpper2_Culture_Null ()
3715 string s = "OrIgInAl";
3718 s.ToUpper ((CultureInfo) null);
3719 Assert.Fail ("#A1");
3720 } catch (ArgumentNullException ex) {
3721 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
3722 Assert.IsNull (ex.InnerException, "#A3");
3723 Assert.IsNotNull (ex.Message, "#A4");
3724 Assert.AreEqual ("culture", ex.ParamName, "#A5");
3728 string.Empty.ToUpper ((CultureInfo) null);
3729 Assert.Fail ("#B1");
3730 } catch (ArgumentNullException ex) {
3731 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
3732 Assert.IsNull (ex.InnerException, "#B3");
3733 Assert.IsNotNull (ex.Message, "#B4");
3734 Assert.AreEqual ("culture", ex.ParamName, "#B5");
3739 public void TestTrim ()
3741 string s1 = " original\t\n";
3742 Assert.AreEqual ("original", s1.Trim(), "basic trim failed");
3743 Assert.AreEqual ("original", s1.Trim(null), "basic trim failed");
3746 Assert.AreEqual ("original", s1.Trim(), "basic trim failed");
3747 Assert.AreEqual ("original", s1.Trim(null), "basic trim failed");
3750 Assert.AreEqual (string.Empty, s1.Trim(), "empty trim failed");
3751 Assert.AreEqual (string.Empty, s1.Trim(null), "empty trim failed");
3753 s1 = "aaaoriginalbbb";
3754 char[] delims = {'a', 'b'};
3755 Assert.AreEqual ("original", s1.Trim(delims), "custom trim failed");
3758 Assert.AreEqual ("original", "\u2028original\u2029".Trim (), "net_2_0 additional char#1");
3759 Assert.AreEqual ("original", "\u0085original\u1680".Trim (), "net_2_0 additional char#2");
3764 public void TestTrimEnd ()
3766 string s1 = " original\t\n";
3767 Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed");
3770 Assert.AreEqual (" original", s1.TrimEnd(null), "basic TrimEnd failed");
3773 Assert.AreEqual (string.Empty, s1.TrimEnd(null), "empty TrimEnd failed");
3775 s1 = "aaaoriginalbbb";
3776 char[] delims = {'a', 'b'};
3777 Assert.AreEqual ("aaaoriginal", s1.TrimEnd(delims), "custom TrimEnd failed");
3781 public void TestTrimStart ()
3783 string s1 = " original\t\n";
3784 Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed");
3786 s1 = "original\t\n";
3787 Assert.AreEqual ("original\t\n", s1.TrimStart(null), "basic TrimStart failed");
3790 Assert.AreEqual (string.Empty, s1.TrimStart(null), "empty TrimStart failed");
3792 s1 = "aaaoriginalbbb";
3793 char[] delims = {'a', 'b'};
3794 Assert.AreEqual ("originalbbb", s1.TrimStart(delims), "custom TrimStart failed");
3798 public void TestChars ()
3805 Assert.Fail ("#A1:" + c);
3806 } catch (IndexOutOfRangeException ex) {
3807 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#A2");
3808 Assert.IsNull (ex.InnerException, "#A3");
3809 Assert.IsNotNull (ex.Message, "#A4");
3815 Assert.Fail ("#B1:" + c);
3816 } catch (IndexOutOfRangeException ex) {
3817 Assert.AreEqual (typeof (IndexOutOfRangeException), ex.GetType (), "#B2");
3818 Assert.IsNull (ex.InnerException, "#B3");
3819 Assert.IsNotNull (ex.Message, "#B4");
3824 public void TestComparePeriod ()
3826 // according to bug 63981, this behavior is for all cultures
3827 Assert.AreEqual (-1, String.Compare ("foo.obj", "foobar.obj", false), "#1");
3831 public void LastIndexOfAnyBounds1 ()
3833 string mono = "Mono";
3834 char [] k = { 'M' };
3836 mono.LastIndexOfAny (k, mono.Length, 1);
3838 } catch (ArgumentOutOfRangeException ex) {
3839 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
3840 Assert.IsNull (ex.InnerException, "#3");
3841 Assert.IsNotNull (ex.Message, "#4");
3842 Assert.AreEqual ("startIndex", ex.ParamName, "#5");
3847 public void TestSplit ()
3849 string s1 = "abcdefghijklm";
3850 char[] c1 = {'q', 'r'};
3851 Assert.AreEqual (s1, (s1.Split(c1))[0], "No splitters");
3853 char[] c2 = {'a', 'e', 'i', 'o', 'u'};
3854 string[] chunks = s1.Split(c2);
3855 Assert.AreEqual (string.Empty, chunks[0], "First chunk");
3856 Assert.AreEqual ("bcd", chunks[1], "Second chunk");
3857 Assert.AreEqual ("fgh", chunks[2], "Third chunk");
3858 Assert.AreEqual ("jklm", chunks[3], "Fourth chunk");
3861 bool errorThrown = false;
3863 chunks = s1.Split(c2, -1);
3864 } catch (ArgumentOutOfRangeException) {
3867 Assert.IsTrue (errorThrown, "Split out of range");
3870 chunks = s1.Split(c2, 2);
3871 Assert.AreEqual (2, chunks.Length, "Limited chunk");
3872 Assert.AreEqual (string.Empty, chunks[0], "First limited chunk");
3873 Assert.AreEqual ("bcdefghijklm", chunks[1], "Second limited chunk");
3877 chunks = s3.Split(c3,2);
3878 Assert.AreEqual (2, chunks.Length, "1.0 split length");
3879 Assert.AreEqual ("1", chunks[0], "1.0 split first chunk");
3880 Assert.AreEqual ("0", chunks[1], "1.0 split second chunk");
3882 string s4 = "1.0.0";
3884 chunks = s4.Split(c4,2);
3885 Assert.AreEqual (2, chunks.Length, "1.0.0 split length");
3886 Assert.AreEqual ("1", chunks[0], "1.0.0 split first chunk");
3887 Assert.AreEqual ("0.0", chunks[1], "1.0.0 split second chunk");
3891 chunks = s5.Split (c5, 2);
3892 Assert.AreEqual (2, chunks.Length, ".0.0 split length");
3893 Assert.AreEqual (string.Empty, chunks[0], ".0.0 split first chunk");
3894 Assert.AreEqual ("0.0", chunks[1], ".0.0 split second chunk");
3898 chunks = s6.Split (c6, 2);
3899 Assert.AreEqual (2, chunks.Length, ".0 split length");
3900 Assert.AreEqual (string.Empty, chunks[0], ".0 split first chunk");
3901 Assert.AreEqual ("0", chunks[1], ".0 split second chunk");
3905 chunks = s7.Split (c7, 2);
3906 Assert.AreEqual (2, chunks.Length, "0. split length");
3907 Assert.AreEqual ("0", chunks[0], "0. split first chunk");
3908 Assert.AreEqual (string.Empty, chunks[1], "0. split second chunk");
3910 string s8 = "0.0000";
3912 chunks = s8.Split (c8, 2);
3913 Assert.AreEqual (2, chunks.Length, "0.0000/2 split length");
3914 Assert.AreEqual ("0", chunks[0], "0.0000/2 split first chunk");
3915 Assert.AreEqual ("0000", chunks[1], "0.0000/2 split second chunk");
3917 chunks = s8.Split (c8, 3);
3918 Assert.AreEqual (2, chunks.Length, "0.0000/3 split length");
3919 Assert.AreEqual ("0", chunks[0], "0.0000/3 split first chunk");
3920 Assert.AreEqual ("0000", chunks[1], "0.0000/3 split second chunk");
3922 chunks = s8.Split (c8, 1);
3923 Assert.AreEqual (1, chunks.Length, "0.0000/1 split length");
3924 Assert.AreEqual ("0.0000", chunks[0], "0.0000/1 split first chunk");
3926 chunks = s1.Split(c2, 1);
3927 Assert.AreEqual (1, chunks.Length, "Single split");
3928 Assert.AreEqual (s1, chunks[0], "Single chunk");
3930 chunks = s1.Split(c2, 0);
3931 Assert.AreEqual (0, chunks.Length, "Zero split");
3935 public void MoreSplit ()
3937 string test = "123 456 789";
3938 string [] st = test.Split ();
3939 Assert.AreEqual ("123", st [0], "#01");
3940 st = test.Split (null);
3941 Assert.AreEqual ("123", st [0], "#02");
3945 [Test] // Split (Char [], StringSplitOptions)
3946 public void Split3_Options_Invalid ()
3949 "A B".Split (new Char [] { 'A' }, (StringSplitOptions) 4096);
3951 } catch (ArgumentException ex) {
3952 // Illegal enum value: 4096
3953 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3954 Assert.IsNull (ex.InnerException, "#3");
3955 Assert.IsNotNull (ex.Message, "#4");
3956 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3957 Assert.IsNull (ex.ParamName, "#6");
3961 [Test] // Split (Char [], StringSplitOptions)
3962 public void Split4_Options_Invalid ()
3965 "A B".Split (new String [] { "A" }, (StringSplitOptions) 4096);
3967 } catch (ArgumentException ex) {
3968 // Illegal enum value: 4096
3969 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3970 Assert.IsNull (ex.InnerException, "#3");
3971 Assert.IsNotNull (ex.Message, "#4");
3972 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3973 Assert.IsNull (ex.ParamName, "#6");
3977 [Test] // Split (Char [], StringSplitOptions)
3978 public void Split5_Options_Invalid ()
3981 "A B".Split (new Char [] { 'A' }, 0, (StringSplitOptions) 4096);
3983 } catch (ArgumentException ex) {
3984 // Illegal enum value: 4096
3985 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3986 Assert.IsNull (ex.InnerException, "#3");
3987 Assert.IsNotNull (ex.Message, "#4");
3988 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
3989 Assert.IsNull (ex.ParamName, "#6");
3993 [Test] // Split (String [], Int32, StringSplitOptions)
3994 public void Split6_Count_Negative ()
3997 "A B".Split (new String [] { "A" }, -1, StringSplitOptions.None);
3999 } catch (ArgumentOutOfRangeException ex) {
4000 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
4001 Assert.IsNull (ex.InnerException, "#3");
4002 Assert.IsNotNull (ex.Message, "#4");
4003 Assert.AreEqual ("count", ex.ParamName, "#5");
4007 [Test] // Split (String [], Int32, StringSplitOptions)
4008 public void Split6_Options_Invalid ()
4011 "A B".Split (new String [] { "A" }, 0, (StringSplitOptions) 4096);
4013 } catch (ArgumentException ex) {
4014 // Illegal enum value: 4096
4015 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
4016 Assert.IsNull (ex.InnerException, "#3");
4017 Assert.IsNotNull (ex.Message, "#4");
4018 Assert.IsTrue (ex.Message.IndexOf ("4096") != 1, "#5");
4019 Assert.IsNull (ex.ParamName, "#6");
4024 public void SplitString ()
4029 res = "A B C".Split (new String [] { "A" }, 0, StringSplitOptions.None);
4030 Assert.AreEqual (0, res.Length);
4032 // empty and RemoveEmpty
4033 res = string.Empty.Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries);
4034 Assert.AreEqual (0, res.Length);
4037 res = "A B C".Split (new String [] { "D" }, StringSplitOptions.None);
4038 Assert.AreEqual (1, res.Length);
4039 Assert.AreEqual ("A B C", res [0]);
4042 res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.None);
4043 Assert.AreEqual (4, res.Length);
4044 Assert.AreEqual ("A ", res [0]);
4045 Assert.AreEqual (" C ", res [1]);
4046 Assert.AreEqual (string.Empty, res [2]);
4047 Assert.AreEqual (" E", res [3]);
4049 // Same with RemoveEmptyEntries
4050 res = "A B C DD E".Split (new String[] { "B", "D" }, StringSplitOptions.RemoveEmptyEntries);
4051 Assert.AreEqual (3, res.Length);
4052 Assert.AreEqual ("A ", res [0]);
4053 Assert.AreEqual (" C ", res [1]);
4054 Assert.AreEqual (" E", res [2]);
4056 // Delimiter matches once at the beginning of the string
4057 res = "A B".Split (new String [] { "A" }, StringSplitOptions.RemoveEmptyEntries);
4058 Assert.AreEqual (1, res.Length);
4059 Assert.AreEqual (" B", res [0]);
4061 // Delimiter at the beginning and at the end
4062 res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.None);
4063 Assert.AreEqual (3, res.Length);
4064 Assert.AreEqual (string.Empty, res [0]);
4065 Assert.AreEqual (" C DD ", res [1]);
4066 Assert.AreEqual (string.Empty, res [2]);
4068 res = "B C DD B".Split (new String[] { "B" }, StringSplitOptions.RemoveEmptyEntries);
4069 Assert.AreEqual (1, res.Length);
4070 Assert.AreEqual (" C DD ", res [0]);
4073 res = "A B C DD E".Split (new String[] { "B", "D" }, 2, StringSplitOptions.None);
4074 Assert.AreEqual (2, res.Length);
4075 Assert.AreEqual ("A ", res [0]);
4076 Assert.AreEqual (" C DD E", res [1]);
4079 res = "ABCDEF".Split (new String[] { "EF", "BCDE" }, StringSplitOptions.None);
4080 Assert.AreEqual (2, res.Length);
4081 Assert.AreEqual ("A", res [0]);
4082 Assert.AreEqual ("F", res [1]);
4084 res = "ABCDEF".Split (new String[] { "BCD", "BC" }, StringSplitOptions.None);
4085 Assert.AreEqual (2, res.Length);
4086 Assert.AreEqual ("A", res [0]);
4087 Assert.AreEqual ("EF", res [1]);
4090 res = "A B\nC".Split ((String[])null, StringSplitOptions.None);
4091 Assert.AreEqual (3, res.Length);
4092 Assert.AreEqual ("A", res [0]);
4093 Assert.AreEqual ("B", res [1]);
4094 Assert.AreEqual ("C", res [2]);
4096 res = "A B\nC".Split (new String [0], StringSplitOptions.None);
4097 Assert.AreEqual (3, res.Length);
4098 Assert.AreEqual ("A", res [0]);
4099 Assert.AreEqual ("B", res [1]);
4100 Assert.AreEqual ("C", res [2]);
4104 public void SplitStringChars ()
4109 res = "..A..B..".Split (new Char[] { '.' }, 0, StringSplitOptions.None);
4110 Assert.AreEqual (0, res.Length, "#01-01");
4113 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.None);
4114 Assert.AreEqual (1, res.Length, "#02-01");
4115 Assert.AreEqual ("..A..B..", res [0], "#02-02");
4117 // count == 1 + RemoveEmpty
4118 res = "..A..B..".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries);
4119 Assert.AreEqual (1, res.Length, "#03-01");
4120 Assert.AreEqual ("..A..B..", res [0], "#03-02");
4122 // Strange Case A+B A
4123 res = "...".Split (new Char[] { '.' }, 1, StringSplitOptions.RemoveEmptyEntries);
4124 Assert.AreEqual (1, res.Length, "#ABA-01");
4125 Assert.AreEqual ("...", res [0], "#ABA-02");
4127 // Strange Case A+B B
4128 res = "...".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4129 Assert.AreEqual (0, res.Length, "#ABB-01");
4131 // Keeping Empties and multipe split chars
4132 res = "..A;.B.;".Split (new Char[] { '.', ';' }, StringSplitOptions.None);
4133 Assert.AreEqual (7, res.Length, "#04-01");
4134 Assert.AreEqual (string.Empty, res [0], "#04-02");
4135 Assert.AreEqual (string.Empty, res [1], "#04-03");
4136 Assert.AreEqual ("A", res [2], "#04-04");
4137 Assert.AreEqual (string.Empty, res [3], "#04-05");
4138 Assert.AreEqual ("B", res [4], "#04-06");
4139 Assert.AreEqual (string.Empty, res [5], "#04-07");
4140 Assert.AreEqual (string.Empty, res [6], "#04-08");
4142 // Trimming (3 tests)
4143 res = "..A".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4144 Assert.AreEqual (1, res.Length, "#05-01");
4145 Assert.AreEqual ("A", res [0], "#05-02");
4147 res = "A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4148 Assert.AreEqual (1, res.Length, "#06-01");
4149 Assert.AreEqual ("A", res [0], "#06-02");
4151 res = "..A..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4152 Assert.AreEqual (1, res.Length, "#07-01");
4153 Assert.AreEqual ("A", res [0], "#07-02");
4156 res = "..A..B..".Split (new Char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
4157 Assert.AreEqual (2, res.Length, "#08-01");
4158 Assert.AreEqual ("A", res [0], "#08-02");
4159 Assert.AreEqual ("B..", res [1], "#08-03");
4161 // Whitespace and Long split chain (removing empty chars)
4162 res = " A\tBC\n\rDEF GHI ".Split ((Char[])null, StringSplitOptions.RemoveEmptyEntries);
4163 Assert.AreEqual (4, res.Length, "#09-01");
4164 Assert.AreEqual ("A", res [0], "#09-02");
4165 Assert.AreEqual ("BC", res [1], "#09-03");
4166 Assert.AreEqual ("DEF", res [2], "#09-04");
4167 Assert.AreEqual ("GHI", res [3], "#09-05");
4169 // Nothing but separators
4170 res = "..,.;.,".Split (new Char[]{'.',',',';'},2,StringSplitOptions.RemoveEmptyEntries);
4171 Assert.AreEqual (0, res.Length, "#10-01");
4173 // Complete testseries
4174 char[] dash = new Char[] { '/' };
4175 StringSplitOptions o = StringSplitOptions.RemoveEmptyEntries;
4176 Assert.AreEqual ("hi", "hi".Split (dash, o)[0], "#11-01");
4177 Assert.AreEqual ("hi", "hi/".Split (dash, o)[0], "#11-02");
4178 Assert.AreEqual ("hi", "/hi".Split (dash, o)[0], "#11-03");
4180 Assert.AreEqual ("hi..", "hi../".Split (dash, o)[0], "#11-04-1");
4181 Assert.AreEqual ("hi..", "/hi..".Split (dash, o)[0], "#11-04-2");
4183 res = "/hi/..".Split (dash, o);
4184 Assert.AreEqual ("hi", res[0], "#11-05-1");
4185 Assert.AreEqual ("..", res[1], "#11-05-2");
4186 Assert.AreEqual (2, res.Length, "#11-09-3");
4188 res = "hi/..".Split (dash, o);
4189 Assert.AreEqual ("hi", res[0], "#11-06-1");
4190 Assert.AreEqual ("..", res[1], "#11-06-2");
4191 Assert.AreEqual (2, res.Length, "#11-09-3");
4193 res = "hi/../".Split (dash, o);
4194 Assert.AreEqual ("hi", res[0], "#11-07-1");
4195 Assert.AreEqual ("..", res[1], "#11-07-2");
4196 Assert.AreEqual (2, res.Length, "#11-07-3");
4198 res = "/hi../".Split (dash, o);
4199 Assert.AreEqual ("hi..", res[0], "#11-08-1");
4200 Assert.AreEqual (1, res.Length, "#11-08-2");
4202 res = "/hi/../".Split (dash, o);
4203 Assert.AreEqual ("hi", res[0], "#11-09-1");
4204 Assert.AreEqual ("..", res[1], "#11-09-2");
4205 Assert.AreEqual (2, res.Length, "#11-09-3");
4209 [Category ("NotDotNet")]
4210 public void Normalize1 ()
4212 // .NET does not combine them into U+1F80
4213 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u03B1\u0313\u0345
4214 string s = "\u03B1\u0313\u0345";
4215 Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormC), "#1");
4216 Assert.IsTrue (!s.IsNormalized (NormalizationForm.FormKC), "#2");
4217 Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormC), "#3");
4218 Assert.AreEqual ("\u1F80", s.Normalize (NormalizationForm.FormKC), "#4");
4222 [Category ("NotDotNet")]
4223 public void Normalize2 ()
4225 string s1 = "\u0061\u0301bc";
4226 string s2 = "\u00e1bc";
4227 // .NET does not combine \u0061\0301 into \u00E1
4228 // seealso: http://demo.icu-project.org/icu-bin/nbrowser?t=\u0061\u0301bc
4229 Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormC), "#1");
4230 Assert.AreEqual (s2, s1.Normalize (NormalizationForm.FormKC), "#2");
4234 public void Normalize3 ()
4236 var s = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0654', '\u0652', '\u064A', '\u064F', '\u0648', '\u0654' });
4238 var formC = new string (new char [] { '\u064A', '\u064F', '\u0624', '\u0652', '\u064a', '\u064f', '\u0624' });
4239 var formD = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0652', '\u0654', '\u064a', '\u064f', '\u0648', '\u0654' });
4240 var formKC = new string (new char [] { '\u064A', '\u064F', '\u0624', '\u0652', '\u064a', '\u064f', '\u0624' });
4241 var formKD = new string (new char [] { '\u064A', '\u064F', '\u0648', '\u0652', '\u0654', '\u064a', '\u064f', '\u0648', '\u0654' });
4243 Assert.AreEqual (formD, s.Normalize (NormalizationForm.FormD), "#1");
4244 Assert.AreEqual (formC, s.Normalize (NormalizationForm.FormC), "#2");
4245 Assert.AreEqual (formKD, s.Normalize (NormalizationForm.FormKD), "#3");
4246 Assert.AreEqual (formKC, s.Normalize (NormalizationForm.FormKC), "#4");