private void UpdateParent()
{
//load any parent:
//l-s-r-p -> l-s-r
//l-s-r -> l-s
//l-r -> l
//l-s -> l
//l -> no parent
if (Region.IsSet() && Script.IsSet() && PrivateUse.IsSet())
{
Parent = GetParentLanguageTag($"{Language}-{Script}-{Region}");
}
else if (Region.IsSet() && Script.IsSet())
{
Parent = GetParentLanguageTag($"{Language}-{Script}");
}
else if (Script.IsSet() || Region.IsSet())
{
Parent = GetParentLanguageTag(Language);
}
else
{
Parent = default;
}
}
private void UpdateCultureInfo()
{
try {
if (PrivateUse.IsSet())
{
CultureInfo = new CultureInfo(OriginalLanguageTag.Replace($"-x-{PrivateUse}", string.Empty));
}
else
{
CultureInfo = new CultureInfo(OriginalLanguageTag);
}
}
catch (ArgumentException) { }
}
// Operations
/// <summary>
/// Performs 'language matching' between lang described by this (A)
/// and language decibed by i_rhs (B). Essentially, returns an assessment of
/// how well a speaker of A will understand B.
/// The key points are as follows:
/// · The Script is almost as relevant as the language itself; that is, if
/// you speak a language but do not understand the script, you cannot
/// read that language. Thus a mismatch in Script should score low.
/// · The Region is less relevant than Script to understanding of language.
/// The one exception to this is where the Region has traditionally been
/// used to also indicate the Script. E.g.
/// zh-CH -> Chinese (Simplified) i.e. zh-Hans
/// zh-TW -> Chinese (Traditional) i.e. zh-Hant
/// In these cases we normalize all legacy langtags to their new values
/// before matching. E.g. zh-CH is normalized to zh-Hans.
/// «LX113»
/// </summary>
/// <param name="i_rhs"></param>
/// <returns>
/// Returns a score on to what extent the two languages match. The value ranges from
/// 100 (exact match) down to 0 (fundamental language tag mismatch), with values
/// in between which may be used to compare quality of a match, larger the value
/// meaning better quality.
/// </returns>
/// <remarks>
/// Matching values:
/// RHS
/// this lang lang+script lang+region lang+script+region
/// ----------------------------------------------------------------------------------
/// lang | A D C D
/// lang+script | D A D B
/// lang+region | C D A D
/// lang+script+region | D B D A
///
/// NB: For the purposes of the logic above, lang incorporates Language + PrivateUse subtags.
///
/// A. Exact match (100)
/// All three subtags match.
/// B. Unbalanced Region Mismatch (99) [zh, zh-HK] [zh-Hans, zh-Hans-HK]
/// Language and Script match;
/// one side has Region set while the other doesn't.
/// Here there is the possibility that due to defaults Region matches.
/// C. Balanced Region Mismatch (98) [zh-IK, zh-HK] [zh-Hans-IK, zh-Hans-HK]
/// Language and Script match;
/// both sides have Region set but to different values.
/// Here there is NO possibility that Region matches.
/// D. Unbalanced Script Mismatch (97) [zh-HK, zh-Hant-HK]
/// Language matches, Region may match;
/// one side has Script set while the other doesn't.
/// Here there is the possibility that due to defaults Script matches.
/// E. Balanced Script Mismatch (96)
/// Language matches, Region may match;
/// both sides have Script set but to different values.
/// Here there is NO possibility that Script matches.
/// F. Language Mismatch (0)
/// Language doesn't match.
/// </remarks>
/// <seealso href="http://msdn.microsoft.com/en-us/library/windows/apps/jj673578.aspx"/>
public int Match(LanguageTag i_rhs, MatchGrade matchGrade = MatchGrade.LanguageMatch)
{
if (i_rhs == null)
{
throw new ArgumentNullException("i_rhs");
}
// Either langtag being null fails the match.
if (!Language.IsSet() || !i_rhs.Language.IsSet())
{
return(0);
}
// Init.
bool[] L = { 0 == string.Compare(Language, i_rhs.Language, true), Language.IsSet(), i_rhs.Language.IsSet() };
bool[] S = { 0 == string.Compare(Script, i_rhs.Script, true), Script.IsSet(), i_rhs.Script.IsSet() };
bool[] R = { 0 == string.Compare(Region, i_rhs.Region, true), Region.IsSet(), i_rhs.Region.IsSet() };
bool[] P = { 0 == string.Compare(PrivateUse, i_rhs.PrivateUse, true), PrivateUse.IsSet(), i_rhs.PrivateUse.IsSet() };
// Language incorporates Language + PrivateUse subtags for our logic here.
L[0] = L[0] && P[0];
L[1] = L[1] || P[1];
L[2] = L[2] || P[2];
// Logic.
int score = 100;
// F.
if (!L[0])
{
return(0);
}
// A.
if (S[0] && R[0] && P[0])
{
return(score);
}
--score;
if (matchGrade != MatchGrade.ExactMatch)
{
// B.
if (S[0] && !R[0] && R[1] != R[2])
{
return(score);
}
--score;
if (matchGrade != MatchGrade.DefaultRegion)
{
// C.
if (S[0] && !R[0] && R[1] == R[2])
{
return(score);
}
--score;
if (matchGrade != MatchGrade.ScriptMatch)
{
// D.
if (!S[0] && S[1] != S[2])
{
return(score);
}
--score;
// E.
if (!S[0] && S[1] == S[2])
{
return(score);
}
}
//--score;
//DebugHelpers.WriteLine("LanguageTag.Match -- fallen through: {0}, {1}", ToString(), i_rhs.ToString());
//Debug.Assert(false);
}
}
// F.
return(0);
}
/// <summary>
/// Constructs a new instance based on a language tag string.
/// If successful, then the Language property is set to a valid language subtag.
/// </summary>
/// <param name="langtag">
/// Supports a subset of BCP 47 language tag spec corresponding to the Windows
/// support for language names, namely the following subtags:
/// language (mandatory, 2 alphachars)
/// script (optional, 4 alphachars)
/// region (optional, 2 alphachars | 3 decdigits)
/// privateuse (optional, 4+ alphanumericchars)
/// Example tags supported:
/// "en" [language]
/// "en-US" [language + region]
/// "zh" [language]
/// "zh-HK" [language + region]
/// "zh-123" [language + region]
/// "zh-Hant" [language + script]
/// "zh-Hant-HK" [language + script + region]
/// "en-GB-x-ACMECorp" [language + region + privateuse]
/// </param>
/// <seealso href="http://www.microsoft.com/resources/msdn/goglobal/default.mspx"/>
public LanguageTag(string langtag)
{
m_langtag = langtag.Trim();
// Normalize certain langtags:
// «LX113» http://www.w3.org/International/articles/language-tags/#script
for (int i = 0; i < NormalizedLangTags.GetLength(0); ++i)
{
if (0 == string.Compare(m_langtag, NormalizedLangTags[i, 0], true))
{
m_langtag = NormalizedLangTags[i, 1];
break;
}
}
m_langtagLC = m_langtag.ToLowerInvariant();
// Parse the langtag.
Match match = s_regex_parseLangtag.Match(m_langtag);
if (match.Success &&
match.Groups.Count == 5)
{
Language = match.Groups[1].Value;
Script = match.Groups[2].Value;
Region = match.Groups[3].Value;
PrivateUse = match.Groups[4].Value;
}
// Load any parent:
// l-s-r-p -> l-s-r
// l-s-r -> l-s
// l-r -> l
// l-s -> l
// l -> no parent
if (Region.IsSet() && Script.IsSet() && PrivateUse.IsSet())
{
m_parent = GetCachedInstance(string.Format("{0}-{1}-{2}", Language, Script, Region));
}
else if (Region.IsSet() && Script.IsSet())
{
m_parent = GetCachedInstance(string.Format("{0}-{1}", Language, Script));
}
else if (Script.IsSet() || Region.IsSet())
{
m_parent = GetCachedInstance(Language);
}
else
{
m_parent = null;
}
//
GlobalKey = string.Format("po:{0}", m_langtag).ToLowerInvariant();
//
try {
if (PrivateUse.IsSet())
{ // Strip out the private use subtag to allow CultureInfo to be set, based on the rest of the language tag
CultureInfo = new CultureInfo(langtag.Replace("-x-" + PrivateUse, string.Empty));
}
else
{
CultureInfo = new CultureInfo(langtag);
}
}
catch (System.ArgumentException) {}
//
NativeNameTitleCase = CultureInfo != null?CultureInfo.TextInfo.ToTitleCase(CultureInfo.NativeName) : "m_langtag";
//Debug.Assert(ToString() == langtag);
}
public void TestPositiveCategories()
{
Assert.AreEqual(UppercaseLetter.ToString(), UnicodeCategory(Categories.UppercaseLetter).ToString());
Assert.AreEqual(LowercaseLetter.ToString(), UnicodeCategory(Categories.LowercaseLetter).ToString());
Assert.AreEqual(TitlecaseLetter.ToString(), UnicodeCategory(Categories.TitlecaseLetter).ToString());
Assert.AreEqual(ModifierLetter.ToString(), UnicodeCategory(Categories.ModifierLetter).ToString());
Assert.AreEqual(OtherLetter.ToString(), UnicodeCategory(Categories.OtherLetter).ToString());
Assert.AreEqual(Letter.ToString(), UnicodeCategory(Categories.Letter).ToString());
Assert.AreEqual(NonspacingMark.ToString(), UnicodeCategory(Categories.NonspacingMark).ToString());
Assert.AreEqual(SpacingCombiningMark.ToString(), UnicodeCategory(Categories.SpacingCombiningMark).ToString());
Assert.AreEqual(EnclosingMark.ToString(), UnicodeCategory(Categories.EnclosingMark).ToString());
Assert.AreEqual(Mark.ToString(), UnicodeCategory(Categories.Mark).ToString());
Assert.AreEqual(DecimalDigitNumber.ToString(), UnicodeCategory(Categories.DecimalDigitNumber).ToString());
Assert.AreEqual(LetterNumber.ToString(), UnicodeCategory(Categories.LetterNumber).ToString());
Assert.AreEqual(OtherNumber.ToString(), UnicodeCategory(Categories.OtherNumber).ToString());
Assert.AreEqual(Number.ToString(), UnicodeCategory(Categories.Number).ToString());
Assert.AreEqual(ConnectorPunctuation.ToString(), UnicodeCategory(Categories.ConnectorPunctuation).ToString());
Assert.AreEqual(DashPunctuation.ToString(), UnicodeCategory(Categories.DashPunctuation).ToString());
Assert.AreEqual(OpenPunctuation.ToString(), UnicodeCategory(Categories.OpenPunctuation).ToString());
Assert.AreEqual(ClosePunctuation.ToString(), UnicodeCategory(Categories.ClosePunctuation).ToString());
Assert.AreEqual(InitialquotePunctuation.ToString(), UnicodeCategory(Categories.InitialquotePunctuation).ToString());
Assert.AreEqual(FinalquotePunctuation.ToString(), UnicodeCategory(Categories.FinalquotePunctuation).ToString());
Assert.AreEqual(OtherPunctuation.ToString(), UnicodeCategory(Categories.OtherPunctuation).ToString());
Assert.AreEqual(Punctuation.ToString(), UnicodeCategory(Categories.Punctuation).ToString());
Assert.AreEqual(MathSymbol.ToString(), UnicodeCategory(Categories.MathSymbol).ToString());
Assert.AreEqual(CurrencySymbol.ToString(), UnicodeCategory(Categories.CurrencySymbol).ToString());
Assert.AreEqual(ModifierSymbol.ToString(), UnicodeCategory(Categories.ModifierSymbol).ToString());
Assert.AreEqual(OtherSymbol.ToString(), UnicodeCategory(Categories.OtherSymbol).ToString());
Assert.AreEqual(Patterns.Unicode.Symbol.ToString(), UnicodeCategory(Categories.Symbol).ToString());
Assert.AreEqual(SpaceSeparator.ToString(), UnicodeCategory(Categories.SpaceSeparator).ToString());
Assert.AreEqual(LineSeparator.ToString(), UnicodeCategory(Categories.LineSeparator).ToString());
Assert.AreEqual(ParagraphSeparator.ToString(), UnicodeCategory(Categories.ParagraphSeparator).ToString());
Assert.AreEqual(Separator.ToString(), UnicodeCategory(Categories.Separator).ToString());
Assert.AreEqual(Format.ToString(), UnicodeCategory(Categories.Format).ToString());
Assert.AreEqual(Surrogate.ToString(), UnicodeCategory(Categories.Surrogate).ToString());
Assert.AreEqual(PrivateUse.ToString(), UnicodeCategory(Categories.PrivateUse).ToString());
Assert.AreEqual(NotAssigned.ToString(), UnicodeCategory(Categories.NotAssigned).ToString());
Assert.AreEqual(OtherControl.ToString(), UnicodeCategory(Categories.OtherControl).ToString());
Assert.AreEqual(Control.ToString(), UnicodeCategory(Categories.Control).ToString());
Assert.AreEqual(BasicLatin.ToString(), UnicodeCategory(Categories.BasicLatin).ToString());
Assert.AreEqual(Latin_1Supplement.ToString(), UnicodeCategory(Categories.Latin_1Supplement).ToString());
Assert.AreEqual(LatinExtended_A.ToString(), UnicodeCategory(Categories.LatinExtended_A).ToString());
Assert.AreEqual(LatinExtended_B.ToString(), UnicodeCategory(Categories.LatinExtended_B).ToString());
Assert.AreEqual(IPAExtensions.ToString(), UnicodeCategory(Categories.IPAExtensions).ToString());
Assert.AreEqual(SpacingModifierLetters.ToString(), UnicodeCategory(Categories.SpacingModifierLetters).ToString());
Assert.AreEqual(CombiningDiacriticalMarks.ToString(), UnicodeCategory(Categories.CombiningDiacriticalMarks).ToString());
Assert.AreEqual(Greek.ToString(), UnicodeCategory(Categories.Greek).ToString());
Assert.AreEqual(GreekandCoptic.ToString(), UnicodeCategory(Categories.GreekandCoptic).ToString());
Assert.AreEqual(Cyrillic.ToString(), UnicodeCategory(Categories.Cyrillic).ToString());
Assert.AreEqual(CyrillicSupplement.ToString(), UnicodeCategory(Categories.CyrillicSupplement).ToString());
Assert.AreEqual(Armenian.ToString(), UnicodeCategory(Categories.Armenian).ToString());
Assert.AreEqual(Hebrew.ToString(), UnicodeCategory(Categories.Hebrew).ToString());
Assert.AreEqual(Arabic.ToString(), UnicodeCategory(Categories.Arabic).ToString());
Assert.AreEqual(Syriac.ToString(), UnicodeCategory(Categories.Syriac).ToString());
Assert.AreEqual(Thaana.ToString(), UnicodeCategory(Categories.Thaana).ToString());
Assert.AreEqual(Devanagari.ToString(), UnicodeCategory(Categories.Devanagari).ToString());
Assert.AreEqual(Bengali.ToString(), UnicodeCategory(Categories.Bengali).ToString());
Assert.AreEqual(Gurmukhi.ToString(), UnicodeCategory(Categories.Gurmukhi).ToString());
Assert.AreEqual(Gujarati.ToString(), UnicodeCategory(Categories.Gujarati).ToString());
Assert.AreEqual(Oriya.ToString(), UnicodeCategory(Categories.Oriya).ToString());
Assert.AreEqual(Tamil.ToString(), UnicodeCategory(Categories.Tamil).ToString());
Assert.AreEqual(Telugu.ToString(), UnicodeCategory(Categories.Telugu).ToString());
Assert.AreEqual(Kannada.ToString(), UnicodeCategory(Categories.Kannada).ToString());
Assert.AreEqual(Malayalam.ToString(), UnicodeCategory(Categories.Malayalam).ToString());
Assert.AreEqual(Sinhala.ToString(), UnicodeCategory(Categories.Sinhala).ToString());
Assert.AreEqual(Thai.ToString(), UnicodeCategory(Categories.Thai).ToString());
Assert.AreEqual(Lao.ToString(), UnicodeCategory(Categories.Lao).ToString());
Assert.AreEqual(Tibetan.ToString(), UnicodeCategory(Categories.Tibetan).ToString());
Assert.AreEqual(Myanmar.ToString(), UnicodeCategory(Categories.Myanmar).ToString());
Assert.AreEqual(Georgian.ToString(), UnicodeCategory(Categories.Georgian).ToString());
Assert.AreEqual(HangulJamo.ToString(), UnicodeCategory(Categories.HangulJamo).ToString());
Assert.AreEqual(Ethiopic.ToString(), UnicodeCategory(Categories.Ethiopic).ToString());
Assert.AreEqual(Cherokee.ToString(), UnicodeCategory(Categories.Cherokee).ToString());
Assert.AreEqual(UnifiedCanadianAboriginalSyllabics.ToString(), UnicodeCategory(Categories.UnifiedCanadianAboriginalSyllabics).ToString());
Assert.AreEqual(Ogham.ToString(), UnicodeCategory(Categories.Ogham).ToString());
Assert.AreEqual(Runic.ToString(), UnicodeCategory(Categories.Runic).ToString());
Assert.AreEqual(Tagalog.ToString(), UnicodeCategory(Categories.Tagalog).ToString());
Assert.AreEqual(Hanunoo.ToString(), UnicodeCategory(Categories.Hanunoo).ToString());
Assert.AreEqual(Buhid.ToString(), UnicodeCategory(Categories.Buhid).ToString());
Assert.AreEqual(Tagbanwa.ToString(), UnicodeCategory(Categories.Tagbanwa).ToString());
Assert.AreEqual(Khmer.ToString(), UnicodeCategory(Categories.Khmer).ToString());
Assert.AreEqual(Mongolian.ToString(), UnicodeCategory(Categories.Mongolian).ToString());
Assert.AreEqual(Limbu.ToString(), UnicodeCategory(Categories.Limbu).ToString());
Assert.AreEqual(TaiLe.ToString(), UnicodeCategory(Categories.TaiLe).ToString());
Assert.AreEqual(KhmerSymbols.ToString(), UnicodeCategory(Categories.KhmerSymbols).ToString());
Assert.AreEqual(PhoneticExtensions.ToString(), UnicodeCategory(Categories.PhoneticExtensions).ToString());
Assert.AreEqual(LatinExtendedAdditional.ToString(), UnicodeCategory(Categories.LatinExtendedAdditional).ToString());
Assert.AreEqual(GreekExtended.ToString(), UnicodeCategory(Categories.GreekExtended).ToString());
Assert.AreEqual(GeneralPunctuation.ToString(), UnicodeCategory(Categories.GeneralPunctuation).ToString());
Assert.AreEqual(SuperscriptsandSubscripts.ToString(), UnicodeCategory(Categories.SuperscriptsandSubscripts).ToString());
Assert.AreEqual(CurrencySymbols.ToString(), UnicodeCategory(Categories.CurrencySymbols).ToString());
Assert.AreEqual(CombiningDiacriticalMarksforSymbols.ToString(), UnicodeCategory(Categories.CombiningDiacriticalMarksforSymbols).ToString());
Assert.AreEqual(CombiningMarksforSymbols.ToString(), UnicodeCategory(Categories.CombiningMarksforSymbols).ToString());
Assert.AreEqual(LetterlikeSymbols.ToString(), UnicodeCategory(Categories.LetterlikeSymbols).ToString());
Assert.AreEqual(NumberForms.ToString(), UnicodeCategory(Categories.NumberForms).ToString());
Assert.AreEqual(Arrows.ToString(), UnicodeCategory(Categories.Arrows).ToString());
Assert.AreEqual(MathematicalOperators.ToString(), UnicodeCategory(Categories.MathematicalOperators).ToString());
Assert.AreEqual(MiscellaneousTechnical.ToString(), UnicodeCategory(Categories.MiscellaneousTechnical).ToString());
Assert.AreEqual(ControlPictures.ToString(), UnicodeCategory(Categories.ControlPictures).ToString());
Assert.AreEqual(OpticalCharacterRecognition.ToString(), UnicodeCategory(Categories.OpticalCharacterRecognition).ToString());
Assert.AreEqual(EnclosedAlphanumerics.ToString(), UnicodeCategory(Categories.EnclosedAlphanumerics).ToString());
Assert.AreEqual(BoxDrawing.ToString(), UnicodeCategory(Categories.BoxDrawing).ToString());
Assert.AreEqual(BlockElements.ToString(), UnicodeCategory(Categories.BlockElements).ToString());
Assert.AreEqual(GeometricShapes.ToString(), UnicodeCategory(Categories.GeometricShapes).ToString());
Assert.AreEqual(MiscellaneousSymbols.ToString(), UnicodeCategory(Categories.MiscellaneousSymbols).ToString());
Assert.AreEqual(Dingbats.ToString(), UnicodeCategory(Categories.Dingbats).ToString());
Assert.AreEqual(MiscellaneousMathematicalSymbols_A.ToString(), UnicodeCategory(Categories.MiscellaneousMathematicalSymbols_A).ToString());
Assert.AreEqual(SupplementalArrows_A.ToString(), UnicodeCategory(Categories.SupplementalArrows_A).ToString());
Assert.AreEqual(BraillePatterns.ToString(), UnicodeCategory(Categories.BraillePatterns).ToString());
Assert.AreEqual(SupplementalArrows_B.ToString(), UnicodeCategory(Categories.SupplementalArrows_B).ToString());
Assert.AreEqual(MiscellaneousMathematicalSymbols_B.ToString(), UnicodeCategory(Categories.MiscellaneousMathematicalSymbols_B).ToString());
Assert.AreEqual(SupplementalMathematicalOperators.ToString(), UnicodeCategory(Categories.SupplementalMathematicalOperators).ToString());
Assert.AreEqual(MiscellaneousSymbolsandArrows.ToString(), UnicodeCategory(Categories.MiscellaneousSymbolsandArrows).ToString());
Assert.AreEqual(CJKRadicalsSupplement.ToString(), UnicodeCategory(Categories.CJKRadicalsSupplement).ToString());
Assert.AreEqual(KangxiRadicals.ToString(), UnicodeCategory(Categories.KangxiRadicals).ToString());
Assert.AreEqual(IdeographicDescriptionCharacters.ToString(), UnicodeCategory(Categories.IdeographicDescriptionCharacters).ToString());
Assert.AreEqual(CJKSymbolsandPunctuation.ToString(), UnicodeCategory(Categories.CJKSymbolsandPunctuation).ToString());
Assert.AreEqual(Hiragana.ToString(), UnicodeCategory(Categories.Hiragana).ToString());
Assert.AreEqual(Katakana.ToString(), UnicodeCategory(Categories.Katakana).ToString());
Assert.AreEqual(Bopomofo.ToString(), UnicodeCategory(Categories.Bopomofo).ToString());
Assert.AreEqual(HangulCompatibilityJamo.ToString(), UnicodeCategory(Categories.HangulCompatibilityJamo).ToString());
Assert.AreEqual(Kanbun.ToString(), UnicodeCategory(Categories.Kanbun).ToString());
Assert.AreEqual(BopomofoExtended.ToString(), UnicodeCategory(Categories.BopomofoExtended).ToString());
Assert.AreEqual(KatakanaPhoneticExtensions.ToString(), UnicodeCategory(Categories.KatakanaPhoneticExtensions).ToString());
Assert.AreEqual(EnclosedCJKLettersandMonths.ToString(), UnicodeCategory(Categories.EnclosedCJKLettersandMonths).ToString());
Assert.AreEqual(CJKCompatibility.ToString(), UnicodeCategory(Categories.CJKCompatibility).ToString());
Assert.AreEqual(CJKUnifiedIdeographsExtensionA.ToString(), UnicodeCategory(Categories.CJKUnifiedIdeographsExtensionA).ToString());
Assert.AreEqual(YijingHexagramSymbols.ToString(), UnicodeCategory(Categories.YijingHexagramSymbols).ToString());
Assert.AreEqual(CJKUnifiedIdeographs.ToString(), UnicodeCategory(Categories.CJKUnifiedIdeographs).ToString());
Assert.AreEqual(YiSyllables.ToString(), UnicodeCategory(Categories.YiSyllables).ToString());
Assert.AreEqual(YiRadicals.ToString(), UnicodeCategory(Categories.YiRadicals).ToString());
Assert.AreEqual(HangulSyllables.ToString(), UnicodeCategory(Categories.HangulSyllables).ToString());
Assert.AreEqual(HighSurrogates.ToString(), UnicodeCategory(Categories.HighSurrogates).ToString());
Assert.AreEqual(HighPrivateUseSurrogates.ToString(), UnicodeCategory(Categories.HighPrivateUseSurrogates).ToString());
Assert.AreEqual(LowSurrogates.ToString(), UnicodeCategory(Categories.LowSurrogates).ToString());
Assert.AreEqual(PrivateUseArea.ToString(), UnicodeCategory(Categories.PrivateUseArea).ToString());
Assert.AreEqual(CJKCompatibilityIdeographs.ToString(), UnicodeCategory(Categories.CJKCompatibilityIdeographs).ToString());
Assert.AreEqual(LettericPresentationForms.ToString(), UnicodeCategory(Categories.LettericPresentationForms).ToString());
Assert.AreEqual(ArabicPresentationForms_A.ToString(), UnicodeCategory(Categories.ArabicPresentationForms_A).ToString());
Assert.AreEqual(VariationSelectors.ToString(), UnicodeCategory(Categories.VariationSelectors).ToString());
Assert.AreEqual(CombiningHalfMarks.ToString(), UnicodeCategory(Categories.CombiningHalfMarks).ToString());
Assert.AreEqual(CJKCompatibilityForms.ToString(), UnicodeCategory(Categories.CJKCompatibilityForms).ToString());
Assert.AreEqual(SmallFormVariants.ToString(), UnicodeCategory(Categories.SmallFormVariants).ToString());
Assert.AreEqual(ArabicPresentationForms_B.ToString(), UnicodeCategory(Categories.ArabicPresentationForms_B).ToString());
Assert.AreEqual(HalfwidthandFullwidthForms.ToString(), UnicodeCategory(Categories.HalfwidthandFullwidthForms).ToString());
Assert.AreEqual(Specials.ToString(), UnicodeCategory(Categories.Specials).ToString());
}
