-// CharTest.cs - NUnit Test Cases for the System.Char struct\r
-//\r
-// David Brandt (bucky@keystreams.com)\r
-//\r
-// (C) Ximian, Inc. http://www.ximian.com\r
+// CharTest.cs - NUnit Test Cases for the System.Char struct
+//
+// David Brandt (bucky@keystreams.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
-// \r
-\r
-using NUnit.Framework;\r
-using System;\r
-using System.Globalization;\r
-\r
-namespace MonoTests.System\r
-{\r
-\r
-public class CharTest : TestCase\r
-{\r
- public void TestCompareTo()\r
- {\r
- Char c1 = 'a';\r
- Char c2 = 'b';\r
- Char c3 = 'b';\r
- Assert("Less than", c1.CompareTo(c2) == -1);\r
- Assert("Greater than", c2.CompareTo(c1) == 1);\r
- Assert("Equal 1", c2.CompareTo(c3) == 0);\r
- Assert("Equal 2", c1.CompareTo(c1) == 0);\r
- }\r
- \r
- public void TestEquals()\r
- {\r
- Char c1 = 'a';\r
- Char c2 = 'b';\r
- Char c3 = 'b';\r
- Assert("Same", c1.Equals(c1));\r
- Assert("Same value", c2.Equals(c3));\r
- Assert("Not same", !c1.Equals(c2));\r
- }\r
-\r
- public void TestGetHashValue()\r
- {\r
- Char c1 = ' ';\r
- AssertEquals("deterministic hash code ", c1.GetHashCode(), c1.GetHashCode());\r
- // 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.\r
- }\r
-\r
- public void TestGetNumericValue()\r
- {\r
- Char c1 = ' ';\r
- Char c2 = '3';\r
- AssertEquals("code 1", -1.0, Char.GetNumericValue(c1), 0.1);\r
- AssertEquals("code 2", 3.0, Char.GetNumericValue(c2), 0.1);\r
-\r
- string s1 = " 3 ";\r
- AssertEquals("space not number", -1.0, Char.GetNumericValue(s1, 0), 0.1);\r
- AssertEquals("space not number", 3.0, Char.GetNumericValue(s1, 1), 0.1);\r
- AssertEquals("space not number", -1.0, Char.GetNumericValue(s1, 2), 0.1);\r
- }\r
-\r
- public void TestGetUnicodeCategory()\r
- {\r
- {\r
- char Pe1 = ']';\r
- char Pe2 = '}';\r
- char Pe3 = ')';\r
- AssertEquals("Close Punctuation", \r
- UnicodeCategory.ClosePunctuation, \r
- Char.GetUnicodeCategory(Pe1));\r
- AssertEquals("Close Punctuation", \r
- UnicodeCategory.ClosePunctuation, \r
- Char.GetUnicodeCategory(Pe2));\r
- AssertEquals("Close Punctuation", \r
- UnicodeCategory.ClosePunctuation, \r
- Char.GetUnicodeCategory(Pe3));\r
- }\r
- // TODO - ConnectorPunctuation\r
- {\r
- char c1 = (char)0; // 0000-001F, 007F-009F\r
- char c2 = (char)0x001F;\r
- char c3 = (char)0x007F;\r
- char c4 = (char)0x00F;\r
- AssertEquals("Control", \r
- UnicodeCategory.Control, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("Control", \r
- UnicodeCategory.Control, \r
- Char.GetUnicodeCategory(c2));\r
- AssertEquals("Control", \r
- UnicodeCategory.Control, \r
- Char.GetUnicodeCategory(c3));\r
- AssertEquals("Control", \r
- UnicodeCategory.Control, \r
- Char.GetUnicodeCategory(c4));\r
- }\r
- {\r
- // TODO - more currencies?\r
- char c1 = '$';\r
- AssertEquals("Currency",\r
- UnicodeCategory.CurrencySymbol,\r
- Char.GetUnicodeCategory(c1));\r
- }\r
- {\r
- char c1 = '-';\r
- AssertEquals("Dash Punctuation", \r
- UnicodeCategory.DashPunctuation, \r
- Char.GetUnicodeCategory(c1));\r
- }\r
- {\r
- char c1 = '2';\r
- char c2 = '7';\r
- AssertEquals("Decimal Digit", \r
- UnicodeCategory.DecimalDigitNumber, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("Decimal Digit", \r
- UnicodeCategory.DecimalDigitNumber, \r
- Char.GetUnicodeCategory(c2));\r
- }\r
- // TODO - EnclosingMark\r
- // TODO - FinalQuotePunctuation\r
- // TODO - Format\r
- // TODO - InitialQuotePunctuation\r
- // TODO - LetterNumber\r
- // TODO - LineSeparator (not '\n', that's a control char)\r
- {\r
- char c1 = 'a';\r
- char c2 = 'z';\r
- AssertEquals("LowercaseLetter", \r
- UnicodeCategory.LowercaseLetter, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("LowercaseLetter", \r
- UnicodeCategory.LowercaseLetter, \r
- Char.GetUnicodeCategory(c2));\r
- }\r
- {\r
- char c1 = '+';\r
- char c2 = '=';\r
- AssertEquals("MathSymbol", \r
- UnicodeCategory.MathSymbol, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("MathSymbol", \r
- UnicodeCategory.MathSymbol, \r
- Char.GetUnicodeCategory(c2));\r
- }\r
- // TODO - ModifierSymbol\r
- // TODO - NonSpacingMark\r
- // TODO - OpenPunctuation\r
- {\r
- char c1 = '[';\r
- char c2 = '{';\r
- char c3 = '(';\r
- AssertEquals("OpenPunctuation", \r
- UnicodeCategory.OpenPunctuation, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("OpenPunctuation", \r
- UnicodeCategory.OpenPunctuation, \r
- Char.GetUnicodeCategory(c2));\r
- AssertEquals("OpenPunctuation", \r
- UnicodeCategory.OpenPunctuation, \r
- Char.GetUnicodeCategory(c3));\r
- }\r
- // TODO - OtherLetter\r
- // TODO - OtherNotAssigned\r
- // TODO - OtherNumber\r
- {\r
- char c1 = '/';\r
- AssertEquals("OtherPunctuation", \r
- UnicodeCategory.OtherPunctuation, \r
- Char.GetUnicodeCategory(c1));\r
- }\r
- // TODO - OtherSymbol\r
- // TODO - ParagraphSeparator\r
- // TODO - PrivateUse\r
- {\r
- char c1 = ' ';\r
- AssertEquals("SpaceSeparator", \r
- UnicodeCategory.SpaceSeparator, \r
- Char.GetUnicodeCategory(c1));\r
- }\r
- // TODO - SpacingCombiningMark\r
- {\r
- char c1 = (char)0xD800; // D800-DBFF\r
- char c2 = (char)0xDBFF; // D800-DBFF\r
- char c3 = (char)0xDC01; // DC00-DEFF\r
- char c4 = (char)0xDEFF; // DC00-DEFF\r
- AssertEquals("High Surrogate", \r
- UnicodeCategory.Surrogate, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("High Surrogate", \r
- UnicodeCategory.Surrogate, \r
- Char.GetUnicodeCategory(c2));\r
- AssertEquals("Low Surrogate", \r
- UnicodeCategory.Surrogate, \r
- Char.GetUnicodeCategory(c3));\r
- AssertEquals("Low Surrogate", \r
- UnicodeCategory.Surrogate, \r
- Char.GetUnicodeCategory(c4));\r
- }\r
- // TODO - TitlecaseLetter\r
- // TODO - UppercaseLetter\r
- {\r
- char c1 = 'A';\r
- char c2 = 'Z';\r
- AssertEquals("UppercaseLetter", \r
- UnicodeCategory.UppercaseLetter, \r
- Char.GetUnicodeCategory(c1));\r
- AssertEquals("UppercaseLetter", \r
- UnicodeCategory.UppercaseLetter, \r
- Char.GetUnicodeCategory(c2));\r
- }\r
- }\r
-\r
- public void TestIsControl()\r
- {\r
- // control is 0000-001F, 007F-009F\r
- char c1 = (char)0;\r
- char c2 = (char)0x001F;\r
- char c3 = (char)0x007F;\r
- char c4 = (char)0x009F;\r
- Assert("Not control", !Char.IsControl(' '));\r
- Assert("control", Char.IsControl(c1));\r
- Assert("control", Char.IsControl(c2));\r
- Assert("control", Char.IsControl(c3));\r
- Assert("control", Char.IsControl(c4));\r
-\r
- string s1 = " " + c1 + c2 + c3 + c4;\r
- Assert("Not control", !Char.IsControl(s1, 0));\r
- Assert("control", Char.IsControl(s1, 1));\r
- Assert("control", Char.IsControl(s1, 2));\r
- Assert("control", Char.IsControl(s1, 3));\r
- Assert("control", Char.IsControl(s1, 4));\r
- }\r
-\r
- public void TestIsDigit()\r
- {\r
- char c1 = '0';\r
- char c2 = '9';\r
- Assert("Not digit", !Char.IsDigit(' '));\r
- Assert("digit", Char.IsDigit(c1));\r
- Assert("digit", Char.IsDigit(c2));\r
-\r
- string s1 = " " + c1 + c2;\r
- Assert("Not digit", !Char.IsDigit(s1, 0));\r
- Assert("digit", Char.IsDigit(s1, 1));\r
- Assert("digit", Char.IsDigit(s1, 2));\r
- }\r
-\r
- public void TestIsLetter()\r
- {\r
- char c1 = 'a';\r
- char c2 = 'z';\r
- char c3 = 'A';\r
- char c4 = 'Z';\r
- Assert("Not letter", !Char.IsLetter(' '));\r
- Assert("letter", Char.IsLetter(c1));\r
- Assert("letter", Char.IsLetter(c2));\r
- Assert("letter", Char.IsLetter(c3));\r
- Assert("letter", Char.IsLetter(c4));\r
-\r
- string s1 = " " + c1 + c2 + c3 + c4;\r
- Assert("Not letter", !Char.IsLetter(s1, 0));\r
- Assert("letter", Char.IsLetter(s1, 1));\r
- Assert("letter", Char.IsLetter(s1, 2));\r
- Assert("letter", Char.IsLetter(s1, 3));\r
- Assert("letter", Char.IsLetter(s1, 4));\r
- }\r
-\r
- public void TestIsLetterOrDigit()\r
- {\r
- char c1 = 'a';\r
- char c2 = 'z';\r
- char c3 = 'A';\r
- char c4 = 'Z';\r
- char c5 = '0';\r
- char c6 = '9';\r
- Assert("Not letterordigit", !Char.IsLetterOrDigit(' '));\r
- Assert("letterordigit", Char.IsLetterOrDigit(c1));\r
- Assert("letterordigit", Char.IsLetterOrDigit(c2));\r
- Assert("letterordigit", Char.IsLetterOrDigit(c3));\r
- Assert("letterordigit", Char.IsLetterOrDigit(c4));\r
- Assert("letterordigit", Char.IsLetterOrDigit(c5));\r
- Assert("letterordigit", Char.IsLetterOrDigit(c6));\r
-\r
- string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;\r
- Assert("Not letterordigit", !Char.IsLetterOrDigit(s1, 0));\r
- Assert("letterordigit", Char.IsLetterOrDigit(s1, 1));\r
- Assert("letterordigit", Char.IsLetterOrDigit(s1, 2));\r
- Assert("letterordigit", Char.IsLetterOrDigit(s1, 3));\r
- Assert("letterordigit", Char.IsLetterOrDigit(s1, 4));\r
- Assert("letterordigit", Char.IsLetterOrDigit(s1, 5));\r
- Assert("letterordigit", Char.IsLetterOrDigit(s1, 6));\r
- }\r
-\r
- public void TestIsLower()\r
- {\r
- char c1 = 'a';\r
- char c2 = 'z';\r
- Assert("Not lower", !Char.IsLower(' '));\r
- Assert("lower", Char.IsLower(c1));\r
- Assert("lower", Char.IsLower(c2));\r
-\r
- string s1 = " " + c1 + c2;\r
- Assert("Not lower", !Char.IsLower(s1, 0));\r
- Assert("lower", Char.IsLower(s1, 1));\r
- Assert("lower", Char.IsLower(s1, 2));\r
- }\r
-\r
- public void TestIsNumber()\r
- {\r
- char c1 = '0';\r
- char c2 = '9';\r
- // TODO - IsNumber of less obvious characters\r
-\r
- Assert("Not number", !Char.IsNumber(' '));\r
- Assert("number", Char.IsNumber(c1));\r
- Assert("number", Char.IsNumber(c2));\r
-\r
- string s1 = " " + c1 + c2;\r
- Assert("Not number", !Char.IsNumber(s1, 0));\r
- Assert("number", Char.IsNumber(s1, 1));\r
- Assert("number", Char.IsNumber(s1, 2));\r
- }\r
-\r
- public void TestIsPunctuation()\r
- {\r
- char c1 = '.';\r
- char c2 = '?';\r
- Assert("Not punctuation", !Char.IsPunctuation(' '));\r
- Assert("punctuation", Char.IsPunctuation(c1));\r
- Assert("punctuation", Char.IsPunctuation(c2));\r
-\r
- string s1 = " " + c1 + c2;\r
- Assert("Not punctuation", !Char.IsPunctuation(s1, 0));\r
- Assert("punctuation", Char.IsPunctuation(s1, 1));\r
- Assert("punctuation", Char.IsPunctuation(s1, 2));\r
- }\r
-\r
- public void TestIsSeparator()\r
- {\r
- char c1 = ' ';\r
-\r
- Assert("Not separator", !Char.IsSeparator('.'));\r
- Assert("separator1", Char.IsSeparator(c1));\r
-\r
- string s1 = "." + c1;\r
- Assert("Not separator", !Char.IsSeparator(s1, 0));\r
- Assert("separator1-2", Char.IsSeparator(s1, 1));\r
- }\r
-\r
- public void TestIsSurrogate()\r
- {\r
- // high surrogate - D800-DBFF\r
- // low surrogate - DC00-DEFF\r
- char c1 = (char)0xD800;\r
- char c2 = (char)0xDBFF;\r
- char c3 = (char)0xDC00;\r
- char c4 = (char)0xDEFF;\r
- Assert("Not surrogate", !Char.IsSurrogate(' '));\r
- Assert("surrogate1", Char.IsSurrogate(c1));\r
- Assert("surrogate2", Char.IsSurrogate(c2));\r
- Assert("surrogate3", Char.IsSurrogate(c3));\r
- Assert("surrogate4", Char.IsSurrogate(c4));\r
-\r
- string s1 = " " + c1 + c2 + c3 + c4;\r
- Assert("Not surrogate", !Char.IsSurrogate(s1, 0));\r
- Assert("surrogate1-2", Char.IsSurrogate(s1, 1));\r
- Assert("surrogate2-2", Char.IsSurrogate(s1, 2));\r
- Assert("surrogate3-2", Char.IsSurrogate(s1, 3));\r
- Assert("surrogate4-2", Char.IsSurrogate(s1, 4));\r
- }\r
-\r
- public void TestIsSymbol()\r
- {\r
- char c1 = '+';\r
- char c2 = '=';\r
- Assert("Not symbol", !Char.IsSymbol(' '));\r
- Assert("symbol", Char.IsSymbol(c1));\r
- Assert("symbol", Char.IsSymbol(c2));\r
-\r
- string s1 = " " + c1 + c2;\r
- Assert("Not symbol", !Char.IsSymbol(s1, 0));\r
- Assert("symbol", Char.IsSymbol(s1, 1));\r
- Assert("symbol", Char.IsSymbol(s1, 2));\r
- }\r
-\r
- public void TestIsUpper()\r
- {\r
- char c1 = 'A';\r
- char c2 = 'Z';\r
- Assert("Not upper", !Char.IsUpper('a'));\r
- Assert("upper", Char.IsUpper(c1));\r
- Assert("upper", Char.IsUpper(c2));\r
-\r
- string s1 = "a" + c1 + c2;\r
- Assert("Not upper", !Char.IsUpper(s1, 0));\r
- Assert("upper", Char.IsUpper(s1, 1));\r
- Assert("upper", Char.IsUpper(s1, 2));\r
- }\r
-\r
- public void TestIsWhiteSpace()\r
- {\r
- char c1 = ' ';\r
- char c2 = '\n';\r
- char c3 = '\t';\r
-\r
- Assert("Not whitespace", !Char.IsWhiteSpace('.'));\r
- Assert("whitespace1", Char.IsWhiteSpace(c1));\r
- Assert("whitespace2", Char.IsWhiteSpace(c2));\r
- Assert("whitespace3", Char.IsWhiteSpace(c3));\r
-\r
- string s1 = "." + c1 + c2 + c3;\r
- Assert("Not whitespace", !Char.IsWhiteSpace(s1, 0));\r
- Assert("whitespace1-2", Char.IsWhiteSpace(s1, 1));\r
- Assert("whitespace2-2", Char.IsWhiteSpace(s1, 2));\r
- Assert("whitespace3-2", Char.IsWhiteSpace(s1, 3));\r
- }\r
+//
+
+using NUnit.Framework;
+using System;
+using System.Globalization;
+
+namespace MonoTests.System
+{
+[TestFixture]
+public class CharTest
+{
+ [Test]
+ public void TestCompareTo()
+ {
+ Char c1 = 'a';
+ Char c2 = 'b';
+ Char c3 = 'b';
+ Assert.IsTrue(c1.CompareTo(c2) == -1, "Less than");
+ Assert.IsTrue(c2.CompareTo(c1) == 1, "Greater than");
+ Assert.IsTrue(c2.CompareTo(c3) == 0, "Equal 1");
+ Assert.IsTrue(c1.CompareTo(c1) == 0, "Equal 2");
+ }
+
+ [Test]
+ public void TestEquals()
+ {
+ Char c1 = 'a';
+ Char c2 = 'b';
+ Char c3 = 'b';
+ Assert.IsTrue(c1.Equals(c1), "Same");
+ Assert.IsTrue(c2.Equals(c3), "Same value");
+ Assert.IsTrue(!c1.Equals(c2), "Not same");
+ }
+
+ [Test]
+ public void TestGetHashValue()
+ {
+ Char c1 = ' ';
+ Assert.AreEqual(c1.GetHashCode(), c1.GetHashCode(), "deterministic hash code ");
+ // 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.
+ }
+
+ [Test]
+ public void TestGetNumericValue()
+ {
+ Char c1 = ' ';
+ Char c2 = '3';
+ Assert.AreEqual(-1.0, Char.GetNumericValue(c1), 0.1, "code 1");
+ Assert.AreEqual(3.0, Char.GetNumericValue(c2), 0.1, "code 2");
+
+ string s1 = " 3 ";
+ Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 0), 0.1, "space not number");
+ Assert.AreEqual(3.0, Char.GetNumericValue(s1, 1), 0.1, "space not number");
+ Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 2), 0.1, "space not number");
+ }
+
+ [Test]
+ public void TestGetUnicodeCategory()
+ {
+ {
+ char Pe1 = ']';
+ char Pe2 = '}';
+ char Pe3 = ')';
+ Assert.AreEqual(UnicodeCategory.ClosePunctuation,
+ Char.GetUnicodeCategory(Pe1),
+ "Close Punctuation");
+ Assert.AreEqual(UnicodeCategory.ClosePunctuation,
+ Char.GetUnicodeCategory(Pe2),
+ "Close Punctuation");
+ Assert.AreEqual(UnicodeCategory.ClosePunctuation,
+ Char.GetUnicodeCategory(Pe3),
+ "Close Punctuation");
+ }
+ // TODO - ConnectorPunctuation
+ {
+ char c1 = (char)0; // 0000-001F, 007F-009F
+ char c2 = (char)0x001F;
+ char c3 = (char)0x007F;
+ char c4 = (char)0x00F;
+ Assert.AreEqual(UnicodeCategory.Control,
+ Char.GetUnicodeCategory(c1),
+ "Control");
+ Assert.AreEqual(UnicodeCategory.Control,
+ Char.GetUnicodeCategory(c2),
+ "Control");
+ Assert.AreEqual(UnicodeCategory.Control,
+ Char.GetUnicodeCategory(c3),
+ "Control");
+ Assert.AreEqual(UnicodeCategory.Control,
+ Char.GetUnicodeCategory(c4),
+ "Control");
+ }
+ {
+ // TODO - more currencies?
+ char c1 = '$';
+ Assert.AreEqual(
+ UnicodeCategory.CurrencySymbol,
+ Char.GetUnicodeCategory(c1),
+ "Currency");
+ }
+ {
+ char c1 = '-';
+ Assert.AreEqual(UnicodeCategory.DashPunctuation,
+ Char.GetUnicodeCategory(c1),
+ "Dash Punctuation");
+ }
+ {
+ char c1 = '2';
+ char c2 = '7';
+ Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
+ Char.GetUnicodeCategory(c1),
+ "Decimal Digit");
+ Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
+ Char.GetUnicodeCategory(c2),
+ "Decimal Digit");
+ }
+ // TODO - EnclosingMark
+ // TODO - FinalQuotePunctuation
+ // TODO - Format
+ // TODO - InitialQuotePunctuation
+ // TODO - LetterNumber
+ // TODO - LineSeparator (not '\n', that's a control char)
+ {
+ char c1 = 'a';
+ char c2 = 'z';
+ Assert.AreEqual(UnicodeCategory.LowercaseLetter,
+ Char.GetUnicodeCategory(c1),
+ "LowercaseLetter");
+ Assert.AreEqual(UnicodeCategory.LowercaseLetter,
+ Char.GetUnicodeCategory(c2),
+ "LowercaseLetter");
+ }
+ {
+ char c1 = '+';
+ char c2 = '=';
+ Assert.AreEqual(UnicodeCategory.MathSymbol,
+ Char.GetUnicodeCategory(c1),
+ "MathSymbol");
+ Assert.AreEqual(UnicodeCategory.MathSymbol,
+ Char.GetUnicodeCategory(c2),
+ "MathSymbol");
+ }
+ // TODO - ModifierSymbol
+ // TODO - NonSpacingMark
+ // TODO - OpenPunctuation
+ {
+ char c1 = '[';
+ char c2 = '{';
+ char c3 = '(';
+ Assert.AreEqual(UnicodeCategory.OpenPunctuation,
+ Char.GetUnicodeCategory(c1),
+ "OpenPunctuation");
+ Assert.AreEqual(UnicodeCategory.OpenPunctuation,
+ Char.GetUnicodeCategory(c2),
+ "OpenPunctuation");
+ Assert.AreEqual(UnicodeCategory.OpenPunctuation,
+ Char.GetUnicodeCategory(c3),
+ "OpenPunctuation");
+ }
+ // TODO - OtherLetter
+ // TODO - OtherNotAssigned
+ // TODO - OtherNumber
+ {
+ char c1 = '/';
+ Assert.AreEqual(UnicodeCategory.OtherPunctuation,
+ Char.GetUnicodeCategory(c1),
+ "OtherPunctuation");
+ }
+ // TODO - OtherSymbol
+ // TODO - ParagraphSeparator
+ // TODO - PrivateUse
+ {
+ char c1 = ' ';
+ Assert.AreEqual(UnicodeCategory.SpaceSeparator,
+ Char.GetUnicodeCategory(c1),
+ "SpaceSeparator");
+ }
+ // TODO - SpacingCombiningMark
+ {
+ char c1 = (char)0xD800; // D800-DBFF
+ char c2 = (char)0xDBFF; // D800-DBFF
+ char c3 = (char)0xDC01; // DC00-DEFF
+ char c4 = (char)0xDEFF; // DC00-DEFF
+ Assert.AreEqual(UnicodeCategory.Surrogate,
+ Char.GetUnicodeCategory(c1),
+ "High Surrogate");
+ Assert.AreEqual(UnicodeCategory.Surrogate,
+ Char.GetUnicodeCategory(c2),
+ "High Surrogate");
+ Assert.AreEqual(UnicodeCategory.Surrogate,
+ Char.GetUnicodeCategory(c3),
+ "Low Surrogate");
+ Assert.AreEqual(UnicodeCategory.Surrogate,
+ Char.GetUnicodeCategory(c4),
+ "Low Surrogate");
+ }
+ // TODO - TitlecaseLetter
+ // TODO - UppercaseLetter
+ {
+ char c1 = 'A';
+ char c2 = 'Z';
+ Assert.AreEqual(UnicodeCategory.UppercaseLetter,
+ Char.GetUnicodeCategory(c1),
+ "UppercaseLetter");
+ Assert.AreEqual(UnicodeCategory.UppercaseLetter,
+ Char.GetUnicodeCategory(c2),
+ "UppercaseLetter");
+ }
+ }
+
+ [Test]
+ public void TestGetUnicodeCategoryStringIndex ()
+ {
+ Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 0), UnicodeCategory.OtherLetter, "#C01");
+ Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 1), UnicodeCategory.Surrogate, "#C02");
+ Assert.AreEqual (Char.GetUnicodeCategory ("\uD800", 0), UnicodeCategory.Surrogate, "#C03");
+ Assert.AreEqual (Char.GetUnicodeCategory ("\uD800!", 0), UnicodeCategory.Surrogate, "#C04");
+ Assert.AreEqual (Char.GetUnicodeCategory ("!", 0), UnicodeCategory.OtherPunctuation, "#C05");
+ Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800", 1), UnicodeCategory.Surrogate, "#C06");
+ Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800\uDF80", 1), UnicodeCategory.OtherLetter, "#C07");
+ }
+
+ [Test]
+ public void TestGetUnicodeCategoryAstralPlanes ()
+ {
+ const int up_to = 0x10ffff;
+ // const int increment = 1;
+ const int increment = 0x1000 + 17;
+
+ for (int codepoint = 0x10000; codepoint < up_to; codepoint += increment) {
+ string combined = Char.ConvertFromUtf32 (codepoint);
+
+ Assert.AreEqual (combined.Length, 2, "#D01");
+ Assert.AreEqual (Char.GetUnicodeCategory (combined [0]), UnicodeCategory.Surrogate, "#D02");
+ Assert.AreEqual (Char.GetUnicodeCategory (combined [1]), UnicodeCategory.Surrogate, "#D03");
+ Assert.AreNotEqual (Char.GetUnicodeCategory (combined, 0), UnicodeCategory.Surrogate, "#D04");
+ }
+ }
+
+ [Test]
+ public void TestIsControl()
+ {
+ // control is 0000-001F, 007F-009F
+ char c1 = (char)0;
+ char c2 = (char)0x001F;
+ char c3 = (char)0x007F;
+ char c4 = (char)0x009F;
+ Assert.IsTrue(!Char.IsControl(' '), "Not control");
+ Assert.IsTrue(Char.IsControl(c1), "control");
+ Assert.IsTrue(Char.IsControl(c2), "control");
+ Assert.IsTrue(Char.IsControl(c3), "control");
+ Assert.IsTrue(Char.IsControl(c4), "control");
+
+ string s1 = " " + c1 + c2 + c3 + c4;
+ Assert.IsTrue(!Char.IsControl(s1, 0), "Not control");
+ Assert.IsTrue(Char.IsControl(s1, 1), "control");
+ Assert.IsTrue(Char.IsControl(s1, 2), "control");
+ Assert.IsTrue(Char.IsControl(s1, 3), "control");
+ Assert.IsTrue(Char.IsControl(s1, 4), "control");
+ }
+
+ [Test]
+ public void TestIsDigit()
+ {
+ char c1 = '0';
+ char c2 = '9';
+ Assert.IsTrue(!Char.IsDigit(' '), "Not digit");
+ Assert.IsTrue(Char.IsDigit(c1), "digit");
+ Assert.IsTrue(Char.IsDigit(c2), "digit");
+
+ string s1 = " " + c1 + c2;
+ Assert.IsTrue(!Char.IsDigit(s1, 0), "Not digit");
+ Assert.IsTrue(Char.IsDigit(s1, 1), "digit");
+ Assert.IsTrue(Char.IsDigit(s1, 2), "digit");
+ }
+
+ [Test]
+ public void TestIsLetter()
+ {
+ char c1 = 'a';
+ char c2 = 'z';
+ char c3 = 'A';
+ char c4 = 'Z';
+ Assert.IsTrue(!Char.IsLetter(' '), "Not letter");
+ Assert.IsTrue(Char.IsLetter(c1), "letter");
+ Assert.IsTrue(Char.IsLetter(c2), "letter");
+ Assert.IsTrue(Char.IsLetter(c3), "letter");
+ Assert.IsTrue(Char.IsLetter(c4), "letter");
+
+ string s1 = " " + c1 + c2 + c3 + c4;
+ Assert.IsTrue(!Char.IsLetter(s1, 0), "Not letter");
+ Assert.IsTrue(Char.IsLetter(s1, 1), "letter");
+ Assert.IsTrue(Char.IsLetter(s1, 2), "letter");
+ Assert.IsTrue(Char.IsLetter(s1, 3), "letter");
+ Assert.IsTrue(Char.IsLetter(s1, 4), "letter");
+ }
+
+ [Test]
+ public void TestIsLetterOrDigit()
+ {
+ char c1 = 'a';
+ char c2 = 'z';
+ char c3 = 'A';
+ char c4 = 'Z';
+ char c5 = '0';
+ char c6 = '9';
+ Assert.IsTrue(!Char.IsLetterOrDigit(' '), "Not letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(c1), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(c2), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(c3), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(c4), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(c5), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(c6), "letterordigit");
+
+ string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;
+ Assert.IsTrue(!Char.IsLetterOrDigit(s1, 0), "Not letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(s1, 1), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(s1, 2), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(s1, 3), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(s1, 4), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(s1, 5), "letterordigit");
+ Assert.IsTrue(Char.IsLetterOrDigit(s1, 6), "letterordigit");
+ }
+
+ [Test]
+ public void TestIsLower()
+ {
+ char c1 = 'a';
+ char c2 = 'z';
+ Assert.IsTrue(!Char.IsLower(' '), "Not lower");
+ Assert.IsTrue(Char.IsLower(c1), "lower");
+ Assert.IsTrue(Char.IsLower(c2), "lower");
+
+ string s1 = " " + c1 + c2;
+ Assert.IsTrue(!Char.IsLower(s1, 0), "Not lower");
+ Assert.IsTrue(Char.IsLower(s1, 1), "lower");
+ Assert.IsTrue(Char.IsLower(s1, 2), "lower");
+ }
+
+ [Test]
+ public void TestIsNumber()
+ {
+ char c1 = '0';
+ char c2 = '9';
+ // TODO - IsNumber of less obvious characters
+
+ Assert.IsTrue(!Char.IsNumber(' '), "Not number");
+ Assert.IsTrue(Char.IsNumber(c1), "number");
+ Assert.IsTrue(Char.IsNumber(c2), "number");
+
+ string s1 = " " + c1 + c2;
+ Assert.IsTrue(!Char.IsNumber(s1, 0), "Not number");
+ Assert.IsTrue(Char.IsNumber(s1, 1), "number");
+ Assert.IsTrue(Char.IsNumber(s1, 2), "number");
+ }
+
+ [Test]
+ public void TestIsPunctuation()
+ {
+ char c1 = '.';
+ char c2 = '?';
+ Assert.IsTrue(!Char.IsPunctuation(' '), "Not punctuation");
+ Assert.IsTrue(Char.IsPunctuation(c1), "punctuation");
+ Assert.IsTrue(Char.IsPunctuation(c2), "punctuation");
+
+ string s1 = " " + c1 + c2;
+ Assert.IsTrue(!Char.IsPunctuation(s1, 0), "Not punctuation");
+ Assert.IsTrue(Char.IsPunctuation(s1, 1), "punctuation");
+ Assert.IsTrue(Char.IsPunctuation(s1, 2), "punctuation");
+ }
[Test]
- public void IsWhiteSpace_Complete ()
+ public void TestIsSeparator()
{
- for (int i=0; i < UInt16.MaxValue; i++) {
- Char c = Convert.ToChar (i);
+ char c1 = ' ';
+
+ Assert.IsTrue(!Char.IsSeparator('.'), "Not separator");
+ Assert.IsTrue(Char.IsSeparator(c1), "separator1");
+
+ string s1 = "." + c1;
+ Assert.IsTrue(!Char.IsSeparator(s1, 0), "Not separator");
+ Assert.IsTrue(Char.IsSeparator(s1, 1), "separator1-2");
+ }
+
+ [Test]
+ public void TestIsSurrogate()
+ {
+ // high surrogate - D800-DBFF
+ // low surrogate - DC00-DEFF
+ char c1 = (char)0xD800;
+ char c2 = (char)0xDBFF;
+ char c3 = (char)0xDC00;
+ char c4 = (char)0xDEFF;
+ Assert.IsTrue(!Char.IsSurrogate(' '), "Not surrogate");
+ Assert.IsTrue(Char.IsSurrogate(c1), "surrogate1");
+ Assert.IsTrue(Char.IsSurrogate(c2), "surrogate2");
+ Assert.IsTrue(Char.IsSurrogate(c3), "surrogate3");
+ Assert.IsTrue(Char.IsSurrogate(c4), "surrogate4");
+
+ string s1 = " " + c1 + c2 + c3 + c4;
+ Assert.IsTrue(!Char.IsSurrogate(s1, 0), "Not surrogate");
+ Assert.IsTrue(Char.IsSurrogate(s1, 1), "surrogate1-2");
+ Assert.IsTrue(Char.IsSurrogate(s1, 2), "surrogate2-2");
+ Assert.IsTrue(Char.IsSurrogate(s1, 3), "surrogate3-2");
+ Assert.IsTrue(Char.IsSurrogate(s1, 4), "surrogate4-2");
+ }
+
+ [Test]
+ public void TestIsSymbol()
+ {
+ char c1 = '+';
+ char c2 = '=';
+ Assert.IsTrue(!Char.IsSymbol(' '), "Not symbol");
+ Assert.IsTrue(Char.IsSymbol(c1), "symbol");
+ Assert.IsTrue(Char.IsSymbol(c2), "symbol");
+
+ string s1 = " " + c1 + c2;
+ Assert.IsTrue(!Char.IsSymbol(s1, 0), "Not symbol");
+ Assert.IsTrue(Char.IsSymbol(s1, 1), "symbol");
+ Assert.IsTrue(Char.IsSymbol(s1, 2), "symbol");
+ }
+
+ [Test]
+ public void TestIsUpper()
+ {
+ char c1 = 'A';
+ char c2 = 'Z';
+ Assert.IsTrue(!Char.IsUpper('a'), "Not upper");
+ Assert.IsTrue(Char.IsUpper(c1), "upper");
+ Assert.IsTrue(Char.IsUpper(c2), "upper");
+
+ string s1 = "a" + c1 + c2;
+ Assert.IsTrue(!Char.IsUpper(s1, 0), "Not upper");
+ Assert.IsTrue(Char.IsUpper(s1, 1), "upper");
+ Assert.IsTrue(Char.IsUpper(s1, 2), "upper");
+ }
+
+ [Test]
+ public void TestIsWhiteSpace()
+ {
+ char c1 = ' ';
+ char c2 = '\n';
+ char c3 = '\t';
+
+ Assert.IsTrue(!Char.IsWhiteSpace('.'), "Not whitespace");
+ Assert.IsTrue(Char.IsWhiteSpace(c1), "whitespace1");
+ Assert.IsTrue(Char.IsWhiteSpace(c2), "whitespace2");
+ Assert.IsTrue(Char.IsWhiteSpace(c3), "whitespace3");
+
+ string s1 = "." + c1 + c2 + c3;
+ Assert.IsTrue(!Char.IsWhiteSpace(s1, 0), "Not whitespace");
+ Assert.IsTrue(Char.IsWhiteSpace(s1, 1), "whitespace1-2");
+ Assert.IsTrue(Char.IsWhiteSpace(s1, 2), "whitespace2-2");
+ Assert.IsTrue(Char.IsWhiteSpace(s1, 3), "whitespace3-2");
+
+ for (int i = 0; i < ushort.MaxValue; ++i ) {
switch (i) {
- case 0x0009:\r
- case 0x000A:\r
- case 0x000B:\r
- case 0x000C:\r
- case 0x000D:\r
- case 0x0020:\r
- case 0x0085:\r
- case 0x00A0:\r
- case 0x1680:\r
- case 0x2000:\r
- case 0x2001:\r
- case 0x2002:\r
- case 0x2003:\r
- case 0x2004:\r
- case 0x2005:\r
- case 0x2006:\r
- case 0x2007:\r
- case 0x2008:\r
- case 0x2009:\r
- case 0x200A:\r
- case 0x200B:\r
- case 0x2028:\r
- case 0x2029:\r
- case 0x202F:\r
-#if NET_2_0
- case 0x205F:
-#endif\r
- case 0x3000:
- Assert (i.ToString (), Char.IsWhiteSpace (c));
+ case '\x9':
+ case '\xa':
+ case '\xb':
+ case '\xc':
+ case '\xd':
+ case '\x20':
+ case '\x85':
+ case '\xa0':
+ case '\x1680':
+ case '\x180e':
+ case '\x2000':
+ case '\x2001':
+ case '\x2002':
+ case '\x2003':
+ case '\x2004':
+ case '\x2005':
+ case '\x2006':
+ case '\x2007':
+ case '\x2008':
+ case '\x2009':
+ case '\x200a':
+ case '\x2028':
+ case '\x2029':
+ case '\x202f':
+ case '\x205f':
+ case '\x3000':
+ Assert.IsTrue (char.IsWhiteSpace ((char)i), i.ToString ());
break;
default:
- Assert (i.ToString (), !Char.IsWhiteSpace (c));
+ Assert.IsFalse (char.IsWhiteSpace ((char)i), i.ToString ());
break;
}
}
- }\r
-\r
- public void TestParse()\r
- {\r
- char c1 = 'a';\r
- string s1 = "a";\r
- Assert(c1.Equals(Char.Parse(s1)));\r
- } \r
-\r
-#if NET_2_0
+ }
+
+ [Test]
+ public void TestParse()
+ {
+ char c1 = 'a';
+ string s1 = "a";
+ Assert.IsTrue(c1.Equals(Char.Parse(s1)));
+ }
+
+ [Test]
public void TestTryParseValid ()
{
char c1 = 'a';
string s1 = "a";
char c2;
- AssertEquals ("TryParse1", true, Char.TryParse (s1, out c2));
- AssertEquals ("TryParse2", c2, c1);
+ Assert.AreEqual (true, Char.TryParse (s1, out c2), "TryParse1");
+ Assert.AreEqual (c2, c1, "TryParse2");
}
+ [Test]
public void TestTryParseInvalid ()
{
string s = "abc";
char c;
- AssertEquals ("TryParse3", false, Char.TryParse (s, out c));
- AssertEquals ("TryParse4", '\0', c);
- }
-#endif
-
- public void TestToLower()\r
- {\r
- char a1 = 'a';\r
- char a2 = 'A';\r
- char a3 = 'z';\r
- char a4 = 'Z';\r
- char a5 = ' ';\r
- char a6 = '+';\r
- char b1 = 'a';\r
- char b2 = 'a';\r
- char b3 = 'z';\r
- char b4 = 'z';\r
- char b5 = ' ';\r
- char b6 = '+';\r
- AssertEquals("char lowered", b1, Char.ToLower(a1));\r
- AssertEquals("char lowered", b2, Char.ToLower(a2));\r
- AssertEquals("char lowered", b3, Char.ToLower(a3));\r
- AssertEquals("char lowered", b4, Char.ToLower(a4));\r
- AssertEquals("char lowered", b5, Char.ToLower(a5));\r
- AssertEquals("char lowered", b6, Char.ToLower(a6));\r
- }\r
-\r
- public void TestToUpper()\r
- {\r
- char a1 = 'a';\r
- char a2 = 'A';\r
- char a3 = 'z';\r
- char a4 = 'Z';\r
- char a5 = ' ';\r
- char a6 = '+';\r
- char b1 = 'A';\r
- char b2 = 'A';\r
- char b3 = 'Z';\r
- char b4 = 'Z';\r
- char b5 = ' ';\r
- char b6 = '+';\r
- AssertEquals("char uppered", b1, Char.ToUpper(a1));\r
- AssertEquals("char uppered", b2, Char.ToUpper(a2));\r
- AssertEquals("char uppered", b3, Char.ToUpper(a3));\r
- AssertEquals("char uppered", b4, Char.ToUpper(a4));\r
- AssertEquals("char uppered", b5, Char.ToUpper(a5));\r
- AssertEquals("char uppered", b6, Char.ToUpper(a6));\r
- }\r
-\r
-\r
- public void TestToString()\r
- {\r
- char c1 = 'a';\r
- string s1 = "a";\r
- Assert(s1.Equals(c1.ToString()));\r
- }\r
-\r
- public void TestGetTypeCode()\r
- {\r
- char c1 = 'a';\r
- Assert(c1.GetTypeCode().Equals(TypeCode.Char));\r
- }\r
-\r
-#if NET_2_0\r
- public void TestConvertFromUtf32 ()\r
- {\r
- AssertEquals ("#1", "A", Char.ConvertFromUtf32 (0x41));\r
- AssertEquals ("#2", "\uD800\uDC00", Char.ConvertFromUtf32 (0x10000));\r
- }\r
-\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void TestConvertFromUtf32Fail1 ()\r
- {\r
- Char.ConvertFromUtf32 (-1);\r
- }\r
-\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void TestConvertFromUtf32Fail2 ()\r
- {\r
- Char.ConvertFromUtf32 (0x110001);\r
- }\r
-\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void TestConvertFromUtf32Fail3 ()\r
- {\r
- Char.ConvertFromUtf32 (0xD800);\r
- }\r
-\r
- public void TestConvertToUtf32 ()\r
- {\r
- AssertEquals ("#1", 0x10000, Char.ConvertToUtf32 ('\uD800', '\uDC00'));\r
- AssertEquals ("#2", 0x10FFFF, Char.ConvertToUtf32 ('\uDBFF', '\uDFFF'));\r
- }\r
-\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void TestConvertToUtf32Fail1 ()\r
- {\r
- Char.ConvertToUtf32 ('A', '\uDC00');\r
- }\r
-\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void TestConvertUtf32Fail2 ()\r
- {\r
- Char.ConvertToUtf32 ('\uD800', '\uD800');\r
- }\r
-#endif\r
-}\r
-\r
-}\r
+ Assert.AreEqual (false, Char.TryParse (s, out c), "TryParse3");
+ Assert.AreEqual ('\0', c, "TryParse4");
+ }
+
+ [Test]
+ public void TestToLower()
+ {
+ char a1 = 'a';
+ char a2 = 'A';
+ char a3 = 'z';
+ char a4 = 'Z';
+ char a5 = ' ';
+ char a6 = '+';
+ char b1 = 'a';
+ char b2 = 'a';
+ char b3 = 'z';
+ char b4 = 'z';
+ char b5 = ' ';
+ char b6 = '+';
+ Assert.AreEqual(b1, Char.ToLower(a1), "char lowered");
+ Assert.AreEqual(b2, Char.ToLower(a2), "char lowered");
+ Assert.AreEqual(b3, Char.ToLower(a3), "char lowered");
+ Assert.AreEqual(b4, Char.ToLower(a4), "char lowered");
+ Assert.AreEqual(b5, Char.ToLower(a5), "char lowered");
+ Assert.AreEqual(b6, Char.ToLower(a6), "char lowered");
+ }
+
+ [Test]
+ public void TestToUpper()
+ {
+ char a1 = 'a';
+ char a2 = 'A';
+ char a3 = 'z';
+ char a4 = 'Z';
+ char a5 = ' ';
+ char a6 = '+';
+ char b1 = 'A';
+ char b2 = 'A';
+ char b3 = 'Z';
+ char b4 = 'Z';
+ char b5 = ' ';
+ char b6 = '+';
+ Assert.AreEqual(b1, Char.ToUpper(a1), "char uppered");
+ Assert.AreEqual(b2, Char.ToUpper(a2), "char uppered");
+ Assert.AreEqual(b3, Char.ToUpper(a3), "char uppered");
+ Assert.AreEqual(b4, Char.ToUpper(a4), "char uppered");
+ Assert.AreEqual(b5, Char.ToUpper(a5), "char uppered");
+ Assert.AreEqual(b6, Char.ToUpper(a6), "char uppered");
+ }
+
+ [Test]
+ public void TestToString()
+ {
+ char c1 = 'a';
+ string s1 = "a";
+ Assert.IsTrue(s1.Equals(c1.ToString()));
+ }
+
+ [Test]
+ public void TestGetTypeCode()
+ {
+ char c1 = 'a';
+ Assert.IsTrue(c1.GetTypeCode().Equals(TypeCode.Char));
+ }
+
+ [Test]
+ public void TestConvertFromUtf32 ()
+ {
+ Assert.AreEqual ("A", Char.ConvertFromUtf32 (0x41), "#1");
+ Assert.AreEqual ("\uD800\uDC00", Char.ConvertFromUtf32 (0x10000), "#2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void TestConvertFromUtf32Fail1 ()
+ {
+ Char.ConvertFromUtf32 (-1);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void TestConvertFromUtf32Fail2 ()
+ {
+ Char.ConvertFromUtf32 (0x110001);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void TestConvertFromUtf32Fail3 ()
+ {
+ Char.ConvertFromUtf32 (0xD800);
+ }
+
+ [Test]
+ public void TestConvertToUtf32 ()
+ {
+ Assert.AreEqual (0x10000, Char.ConvertToUtf32 ('\uD800', '\uDC00'), "#1");
+ Assert.AreEqual (0x10FFFF, Char.ConvertToUtf32 ('\uDBFF', '\uDFFF'), "#2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void TestConvertToUtf32Fail1 ()
+ {
+ Char.ConvertToUtf32 ('A', '\uDC00');
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void TestConvertUtf32Fail2 ()
+ {
+ Char.ConvertToUtf32 ('\uD800', '\uD800');
+ }
+}
+
+}
projects / mono.git / blobdiff