1 // CharTest.cs - NUnit Test Cases for the System.Char struct
2 //
3 // David Brandt (bucky@keystreams.com)
4 //
5 // (C) Ximian, Inc.  http://www.ximian.com
6 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
7 //
8 
9 using NUnit.Framework;
10 using System;
11 using System.Globalization;
12 
13 namespace MonoTests.System
14 {
15 [TestFixture]
16 public class CharTest
17 {
18 	[Test]
TestCompareTo()19 	public void TestCompareTo()
20 	{
21 		Char c1 = 'a';
22 		Char c2 = 'b';
23 		Char c3 = 'b';
24 		Assert.IsTrue(c1.CompareTo(c2) == -1, "Less than");
25 		Assert.IsTrue(c2.CompareTo(c1) == 1, "Greater than");
26 		Assert.IsTrue(c2.CompareTo(c3) == 0, "Equal 1");
27 		Assert.IsTrue(c1.CompareTo(c1) == 0, "Equal 2");
28 	}
29 
30 	[Test]
TestEquals()31 	public void TestEquals()
32 	{
33 		Char c1 = 'a';
34 		Char c2 = 'b';
35 		Char c3 = 'b';
36 		Assert.IsTrue(c1.Equals(c1), "Same");
37 		Assert.IsTrue(c2.Equals(c3), "Same value");
38 		Assert.IsTrue(!c1.Equals(c2), "Not same");
39 	}
40 
41 	[Test]
TestGetHashValue()42 	public void TestGetHashValue()
43 	{
44 		Char c1 = ' ';
45 		Assert.AreEqual(c1.GetHashCode(), c1.GetHashCode(), "deterministic hash code ");
46 		// TODO - the spec doesn't say what algorithm is used to get hash codes.  So far, just a weak test for determinism and mostly-uniqueness.
47 	}
48 
49 	[Test]
TestGetNumericValue()50 	public void TestGetNumericValue()
51 	{
52 		Char c1 = ' ';
53 		Char c2 = '3';
54 		Assert.AreEqual(-1.0, Char.GetNumericValue(c1), 0.1, "code 1");
55 		Assert.AreEqual(3.0, Char.GetNumericValue(c2), 0.1, "code 2");
56 
57 		string s1 = " 3 ";
58 		Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 0), 0.1, "space not number");
59 		Assert.AreEqual(3.0, Char.GetNumericValue(s1, 1), 0.1, "space not number");
60 		Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 2), 0.1, "space not number");
61 	}
62 
63 	[Test]
TestGetUnicodeCategory()64 	public void TestGetUnicodeCategory()
65 	{
66 		{
67 			char Pe1 = ']';
68 			char Pe2 = '}';
69 			char Pe3 = ')';
70 			Assert.AreEqual(UnicodeCategory.ClosePunctuation,
71 							Char.GetUnicodeCategory(Pe1),
72 							"Close Punctuation");
73 			Assert.AreEqual(UnicodeCategory.ClosePunctuation,
74 							Char.GetUnicodeCategory(Pe2),
75 							"Close Punctuation");
76 			Assert.AreEqual(UnicodeCategory.ClosePunctuation,
77 							Char.GetUnicodeCategory(Pe3),
78 							"Close Punctuation");
79 		}
80 		// TODO - ConnectorPunctuation
81 		{
82 			char c1 = (char)0; // 0000-001F, 007F-009F
83 			char c2 = (char)0x001F;
84 			char c3 = (char)0x007F;
85 			char c4 = (char)0x00F;
86 			Assert.AreEqual(UnicodeCategory.Control,
87 							Char.GetUnicodeCategory(c1),
88 							"Control");
89 			Assert.AreEqual(UnicodeCategory.Control,
90 							Char.GetUnicodeCategory(c2),
91 							"Control");
92 			Assert.AreEqual(UnicodeCategory.Control,
93 							Char.GetUnicodeCategory(c3),
94 							"Control");
95 			Assert.AreEqual(UnicodeCategory.Control,
96 							Char.GetUnicodeCategory(c4),
97 							"Control");
98 		}
99 		{
100 			// TODO - more currencies?
101 			char c1 = '$';
102 			Assert.AreEqual(
103 				     UnicodeCategory.CurrencySymbol,
104 				     Char.GetUnicodeCategory(c1),
105 					 "Currency");
106 		}
107 		{
108 			char c1 = '-';
109 			Assert.AreEqual(UnicodeCategory.DashPunctuation,
110 							Char.GetUnicodeCategory(c1),
111 							"Dash Punctuation");
112 		}
113 		{
114 			char c1 = '2';
115 			char c2 = '7';
116 			Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
117 							Char.GetUnicodeCategory(c1),
118 							"Decimal Digit");
119 			Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
120 							Char.GetUnicodeCategory(c2),
121 							"Decimal Digit");
122 		}
123 		// TODO - EnclosingMark
124 		// TODO - FinalQuotePunctuation
125 		// TODO - Format
126 		// TODO - InitialQuotePunctuation
127 		// TODO - LetterNumber
128 		// TODO - LineSeparator (not '\n', that's a control char)
129 		{
130 			char c1 = 'a';
131 			char c2 = 'z';
132 			Assert.AreEqual(UnicodeCategory.LowercaseLetter,
133 							Char.GetUnicodeCategory(c1),
134 							"LowercaseLetter");
135 			Assert.AreEqual(UnicodeCategory.LowercaseLetter,
136 							Char.GetUnicodeCategory(c2),
137 							"LowercaseLetter");
138 		}
139 		{
140 			char c1 = '+';
141 			char c2 = '=';
142 			Assert.AreEqual(UnicodeCategory.MathSymbol,
143 							Char.GetUnicodeCategory(c1),
144 							"MathSymbol");
145 			Assert.AreEqual(UnicodeCategory.MathSymbol,
146 							Char.GetUnicodeCategory(c2),
147 							"MathSymbol");
148 		}
149 		// TODO - ModifierSymbol
150 		// TODO - NonSpacingMark
151 		// TODO - OpenPunctuation
152 		{
153 			char c1 = '[';
154 			char c2 = '{';
155 			char c3 = '(';
156 			Assert.AreEqual(UnicodeCategory.OpenPunctuation,
157 							Char.GetUnicodeCategory(c1),
158 							"OpenPunctuation");
159 			Assert.AreEqual(UnicodeCategory.OpenPunctuation,
160 							Char.GetUnicodeCategory(c2),
161 							"OpenPunctuation");
162 			Assert.AreEqual(UnicodeCategory.OpenPunctuation,
163 							Char.GetUnicodeCategory(c3),
164 							"OpenPunctuation");
165 		}
166 		// TODO - OtherLetter
167 		// TODO - OtherNotAssigned
168 		// TODO - OtherNumber
169 		{
170 			char c1 = '/';
171 			Assert.AreEqual(UnicodeCategory.OtherPunctuation,
172 							Char.GetUnicodeCategory(c1),
173 							"OtherPunctuation");
174 		}
175 		// TODO - OtherSymbol
176 		// TODO - ParagraphSeparator
177 		// TODO - PrivateUse
178 		{
179 			char c1 = ' ';
180 			Assert.AreEqual(UnicodeCategory.SpaceSeparator,
181 							Char.GetUnicodeCategory(c1),
182 							"SpaceSeparator");
183 		}
184 		// TODO - SpacingCombiningMark
185 		{
186 			char c1 = (char)0xD800; // D800-DBFF
187 			char c2 = (char)0xDBFF; // D800-DBFF
188 			char c3 = (char)0xDC01; // DC00-DEFF
189 			char c4 = (char)0xDEFF; // DC00-DEFF
190 			Assert.AreEqual(UnicodeCategory.Surrogate,
191 							Char.GetUnicodeCategory(c1),
192 							"High Surrogate");
193 			Assert.AreEqual(UnicodeCategory.Surrogate,
194 							Char.GetUnicodeCategory(c2),
195 							"High Surrogate");
196 			Assert.AreEqual(UnicodeCategory.Surrogate,
197 							Char.GetUnicodeCategory(c3),
198 							"Low Surrogate");
199 			Assert.AreEqual(UnicodeCategory.Surrogate,
200 							Char.GetUnicodeCategory(c4),
201 							"Low Surrogate");
202 		}
203 		// TODO - TitlecaseLetter
204 		// TODO - UppercaseLetter
205 		{
206 			char c1 = 'A';
207 			char c2 = 'Z';
208 			Assert.AreEqual(UnicodeCategory.UppercaseLetter,
209 							Char.GetUnicodeCategory(c1),
210 							"UppercaseLetter");
211 			Assert.AreEqual(UnicodeCategory.UppercaseLetter,
212 							Char.GetUnicodeCategory(c2),
213 							"UppercaseLetter");
214 		}
215 	}
216 
217 	[Test]
TestGetUnicodeCategoryStringIndex()218 	public void TestGetUnicodeCategoryStringIndex ()
219 	{
220 		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 0), UnicodeCategory.OtherLetter, "#C01");
221 		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 1), UnicodeCategory.Surrogate, "#C02");
222 		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800", 0), UnicodeCategory.Surrogate, "#C03");
223 		Assert.AreEqual (Char.GetUnicodeCategory ("\uD800!", 0), UnicodeCategory.Surrogate, "#C04");
224 		Assert.AreEqual (Char.GetUnicodeCategory ("!", 0), UnicodeCategory.OtherPunctuation, "#C05");
225 		Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800", 1), UnicodeCategory.Surrogate, "#C06");
226 		Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800\uDF80", 1), UnicodeCategory.OtherLetter, "#C07");
227 	}
228 
229 	[Test]
TestGetUnicodeCategoryAstralPlanes()230 	public void TestGetUnicodeCategoryAstralPlanes ()
231 	{
232 		const int up_to = 0x10ffff;
233 		// const int increment = 1;
234 		const int increment = 0x1000 + 17;
235 
236 		for (int codepoint = 0x10000; codepoint < up_to; codepoint += increment) {
237 			string combined = Char.ConvertFromUtf32 (codepoint);
238 
239 			Assert.AreEqual (combined.Length, 2, "#D01");
240 			Assert.AreEqual (Char.GetUnicodeCategory (combined [0]), UnicodeCategory.Surrogate, "#D02");
241 			Assert.AreEqual (Char.GetUnicodeCategory (combined [1]), UnicodeCategory.Surrogate, "#D03");
242 			Assert.AreNotEqual (Char.GetUnicodeCategory (combined, 0), UnicodeCategory.Surrogate, "#D04");
243 		}
244 	}
245 
246 	[Test]
TestIsControl()247 	public void TestIsControl()
248 	{
249 		// control is 0000-001F, 007F-009F
250 		char c1 = (char)0;
251 		char c2 = (char)0x001F;
252 		char c3 = (char)0x007F;
253 		char c4 = (char)0x009F;
254 		Assert.IsTrue(!Char.IsControl(' '), "Not control");
255 		Assert.IsTrue(Char.IsControl(c1), "control");
256 		Assert.IsTrue(Char.IsControl(c2), "control");
257 		Assert.IsTrue(Char.IsControl(c3), "control");
258 		Assert.IsTrue(Char.IsControl(c4), "control");
259 
260 		string s1 = " " + c1 + c2 + c3 + c4;
261 		Assert.IsTrue(!Char.IsControl(s1, 0), "Not control");
262 		Assert.IsTrue(Char.IsControl(s1, 1), "control");
263 		Assert.IsTrue(Char.IsControl(s1, 2), "control");
264 		Assert.IsTrue(Char.IsControl(s1, 3), "control");
265 		Assert.IsTrue(Char.IsControl(s1, 4), "control");
266 	}
267 
268 	[Test]
TestIsDigit()269 	public void TestIsDigit()
270 	{
271 		char c1 = '0';
272 		char c2 = '9';
273 		Assert.IsTrue(!Char.IsDigit(' '), "Not digit");
274 		Assert.IsTrue(Char.IsDigit(c1), "digit");
275 		Assert.IsTrue(Char.IsDigit(c2), "digit");
276 
277 		string s1 = " " + c1 + c2;
278 		Assert.IsTrue(!Char.IsDigit(s1, 0), "Not digit");
279 		Assert.IsTrue(Char.IsDigit(s1, 1), "digit");
280 		Assert.IsTrue(Char.IsDigit(s1, 2), "digit");
281 	}
282 
283 	[Test]
TestIsLetter()284 	public void TestIsLetter()
285 	{
286 		char c1 = 'a';
287 		char c2 = 'z';
288 		char c3 = 'A';
289 		char c4 = 'Z';
290 		Assert.IsTrue(!Char.IsLetter(' '), "Not letter");
291 		Assert.IsTrue(Char.IsLetter(c1), "letter");
292 		Assert.IsTrue(Char.IsLetter(c2), "letter");
293 		Assert.IsTrue(Char.IsLetter(c3), "letter");
294 		Assert.IsTrue(Char.IsLetter(c4), "letter");
295 
296 		string s1 = " " + c1 + c2 + c3 + c4;
297 		Assert.IsTrue(!Char.IsLetter(s1, 0), "Not letter");
298 		Assert.IsTrue(Char.IsLetter(s1, 1), "letter");
299 		Assert.IsTrue(Char.IsLetter(s1, 2), "letter");
300 		Assert.IsTrue(Char.IsLetter(s1, 3), "letter");
301 		Assert.IsTrue(Char.IsLetter(s1, 4), "letter");
302 	}
303 
304 	[Test]
TestIsLetterOrDigit()305 	public void TestIsLetterOrDigit()
306 	{
307 		char c1 = 'a';
308 		char c2 = 'z';
309 		char c3 = 'A';
310 		char c4 = 'Z';
311 		char c5 = '0';
312 		char c6 = '9';
313 		Assert.IsTrue(!Char.IsLetterOrDigit(' '), "Not letterordigit");
314 		Assert.IsTrue(Char.IsLetterOrDigit(c1), "letterordigit");
315 		Assert.IsTrue(Char.IsLetterOrDigit(c2), "letterordigit");
316 		Assert.IsTrue(Char.IsLetterOrDigit(c3), "letterordigit");
317 		Assert.IsTrue(Char.IsLetterOrDigit(c4), "letterordigit");
318 		Assert.IsTrue(Char.IsLetterOrDigit(c5), "letterordigit");
319 		Assert.IsTrue(Char.IsLetterOrDigit(c6), "letterordigit");
320 
321 		string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;
322 		Assert.IsTrue(!Char.IsLetterOrDigit(s1, 0), "Not letterordigit");
323 		Assert.IsTrue(Char.IsLetterOrDigit(s1, 1), "letterordigit");
324 		Assert.IsTrue(Char.IsLetterOrDigit(s1, 2), "letterordigit");
325 		Assert.IsTrue(Char.IsLetterOrDigit(s1, 3), "letterordigit");
326 		Assert.IsTrue(Char.IsLetterOrDigit(s1, 4), "letterordigit");
327 		Assert.IsTrue(Char.IsLetterOrDigit(s1, 5), "letterordigit");
328 		Assert.IsTrue(Char.IsLetterOrDigit(s1, 6), "letterordigit");
329 	}
330 
331 	[Test]
TestIsLower()332 	public void TestIsLower()
333 	{
334 		char c1 = 'a';
335 		char c2 = 'z';
336 		Assert.IsTrue(!Char.IsLower(' '), "Not lower");
337 		Assert.IsTrue(Char.IsLower(c1), "lower");
338 		Assert.IsTrue(Char.IsLower(c2), "lower");
339 
340 		string s1 = " " + c1 + c2;
341 		Assert.IsTrue(!Char.IsLower(s1, 0), "Not lower");
342 		Assert.IsTrue(Char.IsLower(s1, 1), "lower");
343 		Assert.IsTrue(Char.IsLower(s1, 2), "lower");
344 	}
345 
346 	[Test]
TestIsNumber()347 	public void TestIsNumber()
348 	{
349 		char c1 = '0';
350 		char c2 = '9';
351 		// TODO - IsNumber of less obvious characters
352 
353 		Assert.IsTrue(!Char.IsNumber(' '), "Not number");
354 		Assert.IsTrue(Char.IsNumber(c1), "number");
355 		Assert.IsTrue(Char.IsNumber(c2), "number");
356 
357 		string s1 = " " + c1 + c2;
358 		Assert.IsTrue(!Char.IsNumber(s1, 0), "Not number");
359 		Assert.IsTrue(Char.IsNumber(s1, 1), "number");
360 		Assert.IsTrue(Char.IsNumber(s1, 2), "number");
361 	}
362 
363 	[Test]
TestIsPunctuation()364 	public void TestIsPunctuation()
365 	{
366 		char c1 = '.';
367 		char c2 = '?';
368 		Assert.IsTrue(!Char.IsPunctuation(' '), "Not punctuation");
369 		Assert.IsTrue(Char.IsPunctuation(c1), "punctuation");
370 		Assert.IsTrue(Char.IsPunctuation(c2), "punctuation");
371 
372 		string s1 = " " + c1 + c2;
373 		Assert.IsTrue(!Char.IsPunctuation(s1, 0), "Not punctuation");
374 		Assert.IsTrue(Char.IsPunctuation(s1, 1), "punctuation");
375 		Assert.IsTrue(Char.IsPunctuation(s1, 2), "punctuation");
376 	}
377 
378 	[Test]
TestIsSeparator()379 	public void TestIsSeparator()
380 	{
381 		char c1 = ' ';
382 
383 		Assert.IsTrue(!Char.IsSeparator('.'), "Not separator");
384 		Assert.IsTrue(Char.IsSeparator(c1), "separator1");
385 
386 		string s1 = "." + c1;
387 		Assert.IsTrue(!Char.IsSeparator(s1, 0), "Not separator");
388 		Assert.IsTrue(Char.IsSeparator(s1, 1), "separator1-2");
389 	}
390 
391 	[Test]
TestIsSurrogate()392 	public void TestIsSurrogate()
393 	{
394 		// high surrogate - D800-DBFF
395 		// low surrogate - DC00-DEFF
396 		char c1 = (char)0xD800;
397 		char c2 = (char)0xDBFF;
398 		char c3 = (char)0xDC00;
399 		char c4 = (char)0xDEFF;
400 		Assert.IsTrue(!Char.IsSurrogate(' '), "Not surrogate");
401 		Assert.IsTrue(Char.IsSurrogate(c1), "surrogate1");
402 		Assert.IsTrue(Char.IsSurrogate(c2), "surrogate2");
403 		Assert.IsTrue(Char.IsSurrogate(c3), "surrogate3");
404 		Assert.IsTrue(Char.IsSurrogate(c4), "surrogate4");
405 
406 		string s1 = " " + c1 + c2 + c3 + c4;
407 		Assert.IsTrue(!Char.IsSurrogate(s1, 0), "Not surrogate");
408 		Assert.IsTrue(Char.IsSurrogate(s1, 1), "surrogate1-2");
409 		Assert.IsTrue(Char.IsSurrogate(s1, 2), "surrogate2-2");
410 		Assert.IsTrue(Char.IsSurrogate(s1, 3), "surrogate3-2");
411 		Assert.IsTrue(Char.IsSurrogate(s1, 4), "surrogate4-2");
412 	}
413 
414 	[Test]
TestIsSymbol()415 	public void TestIsSymbol()
416 	{
417 		char c1 = '+';
418 		char c2 = '=';
419 		Assert.IsTrue(!Char.IsSymbol(' '), "Not symbol");
420 		Assert.IsTrue(Char.IsSymbol(c1), "symbol");
421 		Assert.IsTrue(Char.IsSymbol(c2), "symbol");
422 
423 		string s1 = " " + c1 + c2;
424 		Assert.IsTrue(!Char.IsSymbol(s1, 0), "Not symbol");
425 		Assert.IsTrue(Char.IsSymbol(s1, 1), "symbol");
426 		Assert.IsTrue(Char.IsSymbol(s1, 2), "symbol");
427 	}
428 
429 	[Test]
TestIsUpper()430 	public void TestIsUpper()
431 	{
432 		char c1 = 'A';
433 		char c2 = 'Z';
434 		Assert.IsTrue(!Char.IsUpper('a'), "Not upper");
435 		Assert.IsTrue(Char.IsUpper(c1), "upper");
436 		Assert.IsTrue(Char.IsUpper(c2), "upper");
437 
438 		string s1 = "a" + c1 + c2;
439 		Assert.IsTrue(!Char.IsUpper(s1, 0), "Not upper");
440 		Assert.IsTrue(Char.IsUpper(s1, 1), "upper");
441 		Assert.IsTrue(Char.IsUpper(s1, 2), "upper");
442 	}
443 
444 	[Test]
TestIsWhiteSpace()445 	public void TestIsWhiteSpace()
446 	{
447 		char c1 = ' ';
448 		char c2 = '\n';
449 		char c3 = '\t';
450 
451 		Assert.IsTrue(!Char.IsWhiteSpace('.'), "Not whitespace");
452 		Assert.IsTrue(Char.IsWhiteSpace(c1), "whitespace1");
453 		Assert.IsTrue(Char.IsWhiteSpace(c2), "whitespace2");
454 		Assert.IsTrue(Char.IsWhiteSpace(c3), "whitespace3");
455 
456 		string s1 = "." + c1 + c2 + c3;
457 		Assert.IsTrue(!Char.IsWhiteSpace(s1, 0), "Not whitespace");
458 		Assert.IsTrue(Char.IsWhiteSpace(s1, 1), "whitespace1-2");
459 		Assert.IsTrue(Char.IsWhiteSpace(s1, 2), "whitespace2-2");
460 		Assert.IsTrue(Char.IsWhiteSpace(s1, 3), "whitespace3-2");
461 
462 		for (int i = 0; i < ushort.MaxValue; ++i ) {
463 			switch (i) {
464 			case '\x9':
465 			case '\xa':
466 			case '\xb':
467 			case '\xc':
468 			case '\xd':
469 			case '\x20':
470 			case '\x85':
471 			case '\xa0':
472 			case '\x1680':
473 			case '\x2000':
474 			case '\x2001':
475 			case '\x2002':
476 			case '\x2003':
477 			case '\x2004':
478 			case '\x2005':
479 			case '\x2006':
480 			case '\x2007':
481 			case '\x2008':
482 			case '\x2009':
483 			case '\x200a':
484 			case '\x2028':
485 			case '\x2029':
486 			case '\x202f':
487 			case '\x205f':
488 			case '\x3000':
489 				Assert.IsTrue (char.IsWhiteSpace ((char)i), "\\x" + i.ToString ("x"));
490 				break;
491 			default:
492 				Assert.IsFalse (char.IsWhiteSpace ((char)i), "\\x" + i.ToString ("x"));
493 				break;
494 			}
495 		}
496 	}
497 
498 	[Test]
TestParse()499 	public void TestParse()
500 	{
501 		char c1 = 'a';
502 		string s1 = "a";
503 		Assert.IsTrue(c1.Equals(Char.Parse(s1)));
504 	}
505 
506 	[Test]
TestTryParseValid()507 	public void TestTryParseValid ()
508 	{
509 		char c1 = 'a';
510 		string s1 = "a";
511 		char c2;
512 
513 		Assert.AreEqual (true, Char.TryParse (s1, out c2), "TryParse1");
514 		Assert.AreEqual (c2, c1, "TryParse2");
515 	}
516 
517 	[Test]
TestTryParseInvalid()518 	public void TestTryParseInvalid ()
519 	{
520 		string s = "abc";
521 		char c;
522 		Assert.AreEqual (false, Char.TryParse (s, out c), "TryParse3");
523 		Assert.AreEqual ('\0', c, "TryParse4");
524 	}
525 
526 	[Test]
TestToLower()527 	public void TestToLower()
528 	{
529 		char a1 = 'a';
530 		char a2 = 'A';
531 		char a3 = 'z';
532 		char a4 = 'Z';
533 		char a5 = ' ';
534 		char a6 = '+';
535 		char b1 = 'a';
536 		char b2 = 'a';
537 		char b3 = 'z';
538 		char b4 = 'z';
539 		char b5 = ' ';
540 		char b6 = '+';
541 		Assert.AreEqual(b1, Char.ToLower(a1), "char lowered");
542 		Assert.AreEqual(b2, Char.ToLower(a2), "char lowered");
543 		Assert.AreEqual(b3, Char.ToLower(a3), "char lowered");
544 		Assert.AreEqual(b4, Char.ToLower(a4), "char lowered");
545 		Assert.AreEqual(b5, Char.ToLower(a5), "char lowered");
546 		Assert.AreEqual(b6, Char.ToLower(a6), "char lowered");
547 	}
548 
549 	[Test]
TestToUpper()550 	public void TestToUpper()
551 	{
552 		char a1 = 'a';
553 		char a2 = 'A';
554 		char a3 = 'z';
555 		char a4 = 'Z';
556 		char a5 = ' ';
557 		char a6 = '+';
558 		char b1 = 'A';
559 		char b2 = 'A';
560 		char b3 = 'Z';
561 		char b4 = 'Z';
562 		char b5 = ' ';
563 		char b6 = '+';
564 		Assert.AreEqual(b1, Char.ToUpper(a1), "char uppered");
565 		Assert.AreEqual(b2, Char.ToUpper(a2), "char uppered");
566 		Assert.AreEqual(b3, Char.ToUpper(a3), "char uppered");
567 		Assert.AreEqual(b4, Char.ToUpper(a4), "char uppered");
568 		Assert.AreEqual(b5, Char.ToUpper(a5), "char uppered");
569 		Assert.AreEqual(b6, Char.ToUpper(a6), "char uppered");
570 	}
571 
572 	[Test]
TestToUpperInvariant()573 	public void TestToUpperInvariant ()
574 	{
575 		Assert.AreEqual ('\u01c5', char.ToUpperInvariant ('\u01c5'));
576 	}
577 
578 	[Test]
TestToString()579 	public void TestToString()
580 	{
581 		char c1 = 'a';
582 		string s1 = "a";
583 		Assert.IsTrue(s1.Equals(c1.ToString()));
584 	}
585 
586 	[Test]
TestGetTypeCode()587 	public void TestGetTypeCode()
588 	{
589 		char c1 = 'a';
590 		Assert.IsTrue(c1.GetTypeCode().Equals(TypeCode.Char));
591 	}
592 
593 	[Test]
TestConvertFromUtf32()594 	public void TestConvertFromUtf32 ()
595 	{
596 		Assert.AreEqual ("A", Char.ConvertFromUtf32 (0x41), "#1");
597 		Assert.AreEqual ("\uD800\uDC00", Char.ConvertFromUtf32 (0x10000), "#2");
598 	}
599 
600 	[Test]
601 	[ExpectedException (typeof (ArgumentOutOfRangeException))]
TestConvertFromUtf32Fail1()602 	public void TestConvertFromUtf32Fail1 ()
603 	{
604 		Char.ConvertFromUtf32 (-1);
605 	}
606 
607 	[Test]
608 	[ExpectedException (typeof (ArgumentOutOfRangeException))]
TestConvertFromUtf32Fail2()609 	public void TestConvertFromUtf32Fail2 ()
610 	{
611 		Char.ConvertFromUtf32 (0x110001);
612 	}
613 
614 	[Test]
615 	[ExpectedException (typeof (ArgumentOutOfRangeException))]
TestConvertFromUtf32Fail3()616 	public void TestConvertFromUtf32Fail3 ()
617 	{
618 		Char.ConvertFromUtf32 (0xD800);
619 	}
620 
621 	[Test]
TestConvertToUtf32()622 	public void TestConvertToUtf32 ()
623 	{
624 		Assert.AreEqual (0x10000, Char.ConvertToUtf32 ('\uD800', '\uDC00'), "#1");
625 		Assert.AreEqual (0x10FFFF, Char.ConvertToUtf32 ('\uDBFF', '\uDFFF'), "#2");
626 	}
627 
628 	[Test]
629 	[ExpectedException (typeof (ArgumentOutOfRangeException))]
TestConvertToUtf32Fail1()630 	public void TestConvertToUtf32Fail1 ()
631 	{
632 		Char.ConvertToUtf32 ('A', '\uDC00');
633 	}
634 
635 	[Test]
636 	[ExpectedException (typeof (ArgumentOutOfRangeException))]
TestConvertUtf32Fail2()637 	public void TestConvertUtf32Fail2 ()
638 	{
639 		Char.ConvertToUtf32 ('\uD800', '\uD800');
640 	}
641 }
642 
643 }
644