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