public void GetUnicodeCategory(string s, UnicodeCategory[] expected)
 {
     for (int i = 0; i < expected.Length; i++)
     {
         Assert.Equal(expected[i], CharUnicodeInfo.GetUnicodeCategory(s, i));
     }
 }

 internal Charset(UnicodeCategory cat)
 {
     m_cat = cat;
     for (m_generic=char.MinValue;Char.GetUnicodeCategory(m_generic)!=cat;m_generic++)
         ;
     m_chars[m_generic] = true;
 }

 public static string Filter(this string value, FilterAction matchRule, UnicodeCategory categories)
 {
     return new string((from c in value
                        where matchRule == FilterAction.Keep
                                  ? categories.HasFlag(Char.GetUnicodeCategory(c))
                                  : !categories.HasFlag(Char.GetUnicodeCategory(c))
                        select c).ToArray());
 }

 private void OnDeserialized(StreamingContext ctx)
 {
     this.strLen = this.endIndex + 1;
     this.currTextElementLen = this.nextTextElementLen;
     if (this.charLen == -1)
     {
         this.uc = CharUnicodeInfo.InternalGetUnicodeCategory(this.str, this.index, out this.charLen);
     }
 }

		public YyLexer(ErrorHandler eh) 
		{
			erh = eh;
#if (GENTIME)
			UsingCat(UnicodeCategory.OtherPunctuation);
			m_gencat = UnicodeCategory.OtherPunctuation;
#endif
			new Tfactory(this,"TOKEN",new TCreator(Tokenfactory));
		}

        private void OnDeserialized(StreamingContext ctx) 
        {
            strLen              = endIndex + 1; 
            currTextElementLen  = nextTextElementLen;

            if (charLen == -1)
            { 
                uc = CharUnicodeInfo.InternalGetUnicodeCategory(str, index, out charLen);
            } 
        } 

        private void OnDeserialized(StreamingContext ctx)
        {
            _strLen = _endIndex + 1;
            _currTextElementLen = _nextTextElementLen;

            if (_charLen == -1)
            {
                _uc = CharUnicodeInfo.InternalGetUnicodeCategory(_str, _index, out _charLen);
            }
        }

        public static void IsLetter_Char()
        {
            var categories = new UnicodeCategory[]
            {
            UnicodeCategory.UppercaseLetter,
            UnicodeCategory.LowercaseLetter,
            UnicodeCategory.TitlecaseLetter,
            UnicodeCategory.ModifierLetter,
            UnicodeCategory.OtherLetter
            };
            foreach (char c in GetTestChars(categories))
                Assert.True(char.IsLetter(c));

            foreach (char c in GetTestCharsNotInCategory(categories))
                Assert.False(char.IsLetter(c));
        }

 private bool IsLetterCategory(UnicodeCategory uc) {
     return (uc == UnicodeCategory.UppercaseLetter
          || uc == UnicodeCategory.LowercaseLetter
          || uc == UnicodeCategory.TitlecaseLetter
          || uc == UnicodeCategory.ModifierLetter
          || uc == UnicodeCategory.OtherLetter);
 }

            /* false */ (0 << 29);  // OtherNotAssigned = 29;

        private bool IsWordSeparator(UnicodeCategory category) {
            return (wordSeparatorMask & (1 << (int)category)) != 0;
        }

 internal static bool IsCombiningCategory(UnicodeCategory uc) {
     Contract.Assert(uc >= 0, "uc >= 0");
     return (
         uc == UnicodeCategory.NonSpacingMark ||
         uc == UnicodeCategory.SpacingCombiningMark ||
         uc == UnicodeCategory.EnclosingMark
     );
 }

        public static void IsWhiteSpace_String_Int()
        {
            var categories = new UnicodeCategory[]
            {
            UnicodeCategory.SpaceSeparator,
            UnicodeCategory.LineSeparator,
            UnicodeCategory.ParagraphSeparator
            };
            foreach (char c in GetTestChars(categories))
                Assert.True(char.IsWhiteSpace(c.ToString(), 0));

            // Some control chars are also considered whitespace for legacy reasons.
            // if ((c >= '\x0009' && c <= '\x000d') || c == '\x0085')
            Assert.True(char.IsWhiteSpace("\u000b", 0));
            Assert.True(char.IsWhiteSpace("\u0085", 0));

            foreach (char c in GetTestCharsNotInCategory(categories))
            {
                // Need to special case some control chars that are treated as whitespace
                if ((c >= '\x0009' && c <= '\x000d') || c == '\x0085') continue;
                Assert.False(char.IsWhiteSpace(c.ToString(), 0));
            }
        }

        public static void IsSymbol_String_Int()
        {
            var categories = new UnicodeCategory[]
            {
            UnicodeCategory.MathSymbol,
            UnicodeCategory.ModifierSymbol,
            UnicodeCategory.CurrencySymbol,
            UnicodeCategory.OtherSymbol
            };
            foreach (char c in GetTestChars(categories))
                Assert.True(char.IsSymbol(c.ToString(), 0));

            foreach (char c in GetTestCharsNotInCategory(categories))
                Assert.False(char.IsSymbol(c.ToString(), 0));
        }

        public static void IsPunctuation_String_Int()
        {
            var categories = new UnicodeCategory[]
            {
            UnicodeCategory.ConnectorPunctuation,
            UnicodeCategory.DashPunctuation,
            UnicodeCategory.OpenPunctuation,
            UnicodeCategory.ClosePunctuation,
            UnicodeCategory.InitialQuotePunctuation,
            UnicodeCategory.FinalQuotePunctuation,
            UnicodeCategory.OtherPunctuation
            };
            foreach (char c in GetTestChars(categories))
                Assert.True(char.IsPunctuation(c.ToString(), 0));

            foreach (char c in GetTestCharsNotInCategory(categories))
                Assert.False(char.IsPunctuation(c.ToString(), 0));
        }

        public static void IsLetterOrDigit_String_Int()
        {
            var categories = new UnicodeCategory[]
            {
            UnicodeCategory.UppercaseLetter,
            UnicodeCategory.LowercaseLetter,
            UnicodeCategory.TitlecaseLetter,
            UnicodeCategory.ModifierLetter,
            UnicodeCategory.OtherLetter,
            UnicodeCategory.DecimalDigitNumber
            };
            foreach (char c in GetTestChars(categories))
                Assert.True(char.IsLetterOrDigit(c.ToString(), 0));

            foreach (char c in GetTestCharsNotInCategory(categories))
                Assert.False(char.IsLetterOrDigit(c.ToString(), 0));
        }

		static bool IsSeparator (UnicodeCategory category)
		{
			switch (category) {
			case UnicodeCategory.SpaceSeparator:
			case UnicodeCategory.LineSeparator:
			case UnicodeCategory.ParagraphSeparator:
			case UnicodeCategory.Control:
			case UnicodeCategory.Format:
			case UnicodeCategory.ConnectorPunctuation:
			case UnicodeCategory.DashPunctuation:
			case UnicodeCategory.OpenPunctuation:
			case UnicodeCategory.ClosePunctuation:
			case UnicodeCategory.InitialQuotePunctuation:
			case UnicodeCategory.FinalQuotePunctuation:
			case UnicodeCategory.OtherPunctuation:
				return true;
			}

			return false;
		}

		public void GetAllCharactersInUnicodeCategory_CategoryShouldNotContainCharacter_CategoryDoesNotContainCharacter(UnicodeCategory category, char character)
		{
			Assert.False(CharacterUtils.GetAllCharactersInUnicodeCategory(category).Contains(character));
		}

		public void GetAllCharactersInUnicodeCategory_CategoryShouldContainCharacter_CategoryContainsCharacter(UnicodeCategory category, char character)
		{
			Assert.True(CharacterUtils.GetAllCharactersInUnicodeCategory(category).Contains(character));
		}

		static CharacterClass GetCharacterClass(UnicodeCategory c)
		{
			switch (c) {
				case UnicodeCategory.SpaceSeparator:
				case UnicodeCategory.LineSeparator:
				case UnicodeCategory.ParagraphSeparator:
				case UnicodeCategory.Control:
					return CharacterClass.Whitespace;
				case UnicodeCategory.UppercaseLetter:
				case UnicodeCategory.LowercaseLetter:
				case UnicodeCategory.TitlecaseLetter:
				case UnicodeCategory.ModifierLetter:
				case UnicodeCategory.OtherLetter:
				case UnicodeCategory.DecimalDigitNumber:
					return CharacterClass.IdentifierPart;
				case UnicodeCategory.NonSpacingMark:
				case UnicodeCategory.SpacingCombiningMark:
				case UnicodeCategory.EnclosingMark:
					return CharacterClass.CombiningMark;
				default:
					return CharacterClass.Other;
			}
		}

		private static bool IsCategory (UnicodeCategory uc, char c) {
			if (Char.GetUnicodeCategory (c) == uc)
				return true;

			return false;
		}