public void Load_Nonempty() { CoreWritingSystemDefinition ws1 = m_wsManager.Create("en"); ws1.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "e", "f", "g", "h" } }); ws1.CharacterSets.Add(new CharacterSetDefinition("punctuation") { Characters = { ",", "!", "*" } }); ValidCharacters validChars = ValidCharacters.Load(ws1); var validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(4, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("e")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("f")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("g")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("h")); Assert.AreEqual(3, validCharsW.OtherCharacters.Count); Assert.IsTrue(validCharsW.OtherCharacters.Contains(",")); Assert.IsTrue(validCharsW.OtherCharacters.Contains("!")); Assert.IsTrue(validCharsW.OtherCharacters.Contains("*")); CoreWritingSystemDefinition ws2 = m_wsManager.Create("en"); validChars.SaveTo(ws2); Assert.That(ws1.ValueEquals(ws2), Is.True); }
public void Load_DuplicateCharacters() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ws.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "a", "a" } }); ws.CharacterSets.Add(new CharacterSetDefinition("numeric") { Characters = { "4", "4" } }); ws.CharacterSets.Add(new CharacterSetDefinition("punctuation") { Characters = { "'", "'" } }); ValidCharacters validChars = ValidCharacters.Load(ws); var validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(1, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("a")); Assert.AreEqual(1, validCharsW.NumericCharacters.Count); Assert.IsTrue(validCharsW.NumericCharacters.Contains("4")); Assert.AreEqual(1, validCharsW.OtherCharacters.Count); Assert.IsTrue(validCharsW.OtherCharacters.Contains("'")); }
public void Load_ValidAndBogusCharacters() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ws.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "\u05F6", "g", "\u05F7", "h" } }); ws.CharacterSets.Add(new CharacterSetDefinition("numeric") { Characters = { "1" } }); ValidCharacters validChars = ValidCharacters.Load(ws, RememberError); var validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(2, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("g")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("h")); Assert.AreEqual(1, validCharsW.NumericCharacters.Count); Assert.IsTrue(validCharsW.NumericCharacters.Contains("1")); Assert.AreEqual(0, validCharsW.OtherCharacters.Count); Assert.AreEqual("Invalid ValidChars field while loading the English (United States) writing system. " + "The following characters are invalid:" + Environment.NewLine + "\t\u05F6 (U+05F6)" + Environment.NewLine + "\t\u05F7 (U+05F7)" + Environment.NewLine + "Parameter name: ws", m_lastException.Message); }
public void get_IsWordForming() { var wsManager = new WritingSystemManager(); CoreWritingSystemDefinition ws = wsManager.Set("zh-CN"); ws.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "e", "f", "g", "h", "'" } }); ws.CharacterSets.Add(new CharacterSetDefinition("numeric") { Characters = { "4", "5" } }); ws.CharacterSets.Add(new CharacterSetDefinition("punctuation") { Characters = { ",", "!", "*" } }); Assert.IsTrue(ws.get_IsWordForming('\'')); Assert.IsFalse(ws.get_IsWordForming('"')); ws.CharacterSets.Clear(); Assert.IsFalse(ws.get_IsWordForming('\'')); Assert.IsFalse(ws.get_IsWordForming('"')); wsManager.Save(); }
public void AddCharacter_DuplicateOfOverriddenWordFormingChar() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ws.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "a", "-" } }); ws.CharacterSets.Add(new CharacterSetDefinition("punctuation") { Characters = { "{" } }); ValidCharacters validChars = ValidCharacters.Load(ws); var validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(2, validCharsW.WordFormingCharacters.Count); Assert.AreEqual(0, validCharsW.NumericCharacters.Count); Assert.AreEqual(1, validCharsW.OtherCharacters.Count); Assert.IsTrue(validChars.IsWordForming("-")); Assert.IsFalse(validChars.IsWordForming("{")); validChars.AddCharacter("-"); Assert.AreEqual(2, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("a")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("-")); Assert.IsTrue(validChars.IsWordForming("-")); Assert.AreEqual(0, validCharsW.NumericCharacters.Count); Assert.AreEqual(1, validCharsW.OtherCharacters.Count); Assert.IsTrue(validCharsW.OtherCharacters.Contains("{")); Assert.IsFalse(validChars.IsWordForming("{")); }
/// <summary> /// Copies all of the properties from the source writing system to this writing system. /// </summary> /// <param name="source">The source writing system.</param> public void Copy(CoreWritingSystemDefinition source) { Language = source.Language; Script = source.Script; Region = source.Region; Variants.ReplaceAll(source.Variants); Abbreviation = source.Abbreviation; RightToLeftScript = source.RightToLeftScript; Fonts.ReplaceAll(source.Fonts.CloneItems()); DefaultFont = source.DefaultFont == null ? null : Fonts[source.Fonts.IndexOf(source.DefaultFont)]; Keyboard = source.Keyboard; VersionNumber = source.VersionNumber; VersionDescription = source.VersionDescription; SpellCheckDictionaries.ReplaceAll(source.SpellCheckDictionaries.CloneItems()); SpellCheckingId = source.SpellCheckingId; DateModified = source.DateModified; LocalKeyboard = source.LocalKeyboard; WindowsLcid = source.WindowsLcid; DefaultRegion = source.DefaultRegion; KnownKeyboards.ReplaceAll(source.KnownKeyboards); MatchedPairs.Clear(); MatchedPairs.UnionWith(source.MatchedPairs); PunctuationPatterns.Clear(); PunctuationPatterns.UnionWith(source.PunctuationPatterns); QuotationMarks.ReplaceAll(source.QuotationMarks); QuotationParagraphContinueType = source.QuotationParagraphContinueType; Collations.ReplaceAll(source.Collations.CloneItems()); DefaultCollation = source.DefaultCollation == null ? null : Collations[source.Collations.IndexOf(source.DefaultCollation)]; CharacterSets.ReplaceAll(source.CharacterSets.CloneItems()); LegacyMapping = source.LegacyMapping; IsGraphiteEnabled = source.IsGraphiteEnabled; }
public void InterpretChrp() { var wsManager = new WritingSystemManager(); CoreWritingSystemDefinition ws = wsManager.Create("en-US"); var chrp = new LgCharRenderProps { ws = ws.Handle, szFaceName = new ushort[32], dympHeight = 10000, ssv = (int)FwSuperscriptVal.kssvSuper }; MarshalEx.StringToUShort("<default font>", chrp.szFaceName); ws.InterpretChrp(ref chrp); Assert.AreEqual(ws.DefaultFontName, MarshalEx.UShortToString(chrp.szFaceName)); Assert.AreEqual(10000 / 3, chrp.dympOffset); Assert.AreEqual((10000 * 2) / 3, chrp.dympHeight); Assert.AreEqual((int)FwSuperscriptVal.kssvOff, chrp.ssv); chrp.ssv = (int)FwSuperscriptVal.kssvSub; chrp.dympHeight = 10000; chrp.dympOffset = 0; ws.InterpretChrp(ref chrp); Assert.AreEqual(-(10000 / 5), chrp.dympOffset); Assert.AreEqual((10000 * 2) / 3, chrp.dympHeight); Assert.AreEqual((int)FwSuperscriptVal.kssvOff, chrp.ssv); wsManager.Save(); }
public void Create() { var wsManager = new WritingSystemManager(); CoreWritingSystemDefinition enWS = wsManager.Create("en-Latn-US-fonipa"); Assert.That(enWS.Abbreviation, Is.EqualTo("Eng")); Assert.That(enWS.Language, Is.EqualTo((LanguageSubtag)"en")); Assert.That(enWS.Script, Is.EqualTo((ScriptSubtag)"Latn")); Assert.That(enWS.Region, Is.EqualTo((RegionSubtag)"US")); Assert.That(enWS.Variants, Is.EqualTo(new VariantSubtag[] { "fonipa" })); Assert.That(enWS.DefaultFontName, Is.EqualTo("Charis SIL")); Assert.That(enWS.DefaultCollation.ValueEquals(new IcuRulesCollationDefinition("standard")), Is.True); Assert.That(enWS.LanguageTag, Is.EqualTo("en-US-fonipa")); Assert.That(string.IsNullOrEmpty(enWS.WindowsLcid), Is.True); CoreWritingSystemDefinition chWS = wsManager.Create("zh-CN"); Assert.That(chWS.Abbreviation, Is.EqualTo("Chi")); Assert.That(chWS.Language, Is.EqualTo((LanguageSubtag)"zh")); Assert.That(chWS.Script, Is.EqualTo((ScriptSubtag)"Hans")); Assert.That(chWS.Region, Is.EqualTo((RegionSubtag)"CN")); Assert.That(chWS.DefaultFontName, Is.EqualTo("Charis SIL")); Assert.That(chWS.DefaultCollation.ValueEquals(new SystemCollationDefinition { LanguageTag = "zh-CN" }), Is.True); }
public void GetNaturalCharType(int codepoint, ValidCharacterType type) { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ValidCharacters validChars = ValidCharacters.Load(ws); Assert.AreEqual(type, ReflectionHelper.GetResult(validChars, "GetNaturalCharType", codepoint)); }
/// <summary> /// Replaces an existing writing system with the specified new writing system if they /// have the same identifier. /// </summary> /// <param name="ws">The writing system.</param> public void Replace(CoreWritingSystemDefinition ws) { lock (m_syncRoot) { CoreWritingSystemDefinition existingWs; if (TryGet(ws.LanguageTag, out existingWs)) { if (existingWs == ws) { // don't do anything return; } m_handleWSs.Remove(existingWs.Handle); m_repo.Remove(existingWs.Id); m_repo.Set(ws); ws.WritingSystemFactory = this; ws.Handle = existingWs.Handle; m_handleWSs[ws.Handle] = ws; } else { Set(ws); } } }
public void SortAfterAddRange() { CoreWritingSystemDefinition ws = m_wsManager.Create("en"); ValidCharacters validChars = ValidCharacters.Load(ws); validChars.AddCharacters(new[] { "z", "c", "t", "b", "8", "7", "6", "5" }); VerifySortOrder(validChars); }
public void GetStrFromWs() { var wsManager = new WritingSystemManager(); Assert.IsNull(wsManager.GetStrFromWs(1)); CoreWritingSystemDefinition ws = wsManager.Set("en-US"); Assert.AreEqual("en-US", wsManager.GetStrFromWs(ws.Handle)); wsManager.Save(); }
public void get_EngineOrNull() { var wsManager = new WritingSystemManager(); Assert.IsNull(wsManager.get_EngineOrNull(1)); CoreWritingSystemDefinition ws = wsManager.Set("en-US"); Assert.AreSame(ws, wsManager.get_EngineOrNull(ws.Handle)); wsManager.Save(); }
/// <summary> /// Sets the specified writing system. /// </summary> /// <param name="ws">The writing system.</param> public void Set(CoreWritingSystemDefinition ws) { lock (m_syncRoot) { m_repo.Set(ws); ws.WritingSystemFactory = this; ws.Handle = m_nextHandle++; m_handleWSs[ws.Handle] = ws; } }
public void GetWsFromStr() { var wsManager = new WritingSystemManager(); Assert.AreEqual(0, wsManager.GetWsFromStr("en-US")); CoreWritingSystemDefinition ws = wsManager.Set("en-US"); Assert.AreEqual(ws.Handle, wsManager.GetWsFromStr("en-US")); wsManager.Save(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Loads the valid characters from the specified language definition into a new /// instance of the <see cref="ValidCharacters"/> class. /// </summary> /// <returns>A <see cref="ValidCharacters"/> initialized with the valid characters data /// from the language definition.</returns> /// ------------------------------------------------------------------------------------ public static ValidCharacters Load(CoreWritingSystemDefinition ws) { var validChars = new ValidCharacters(); validChars.AddCharactersFromWritingSystem(ws, "main", ValidCharacterType.WordForming); validChars.AddCharactersFromWritingSystem(ws, "punctuation", ValidCharacterType.Other); validChars.InitSortComparer(ws); return(validChars); }
/// <summary> /// Gets the specified writing system if it exists, otherwise it creates /// a writing system using the specified identifier and sets it. /// </summary> /// <param name="identifier">The identifier.</param> /// <param name="ws">The writing system.</param> /// <returns><c>true</c> if the writing system already existed, otherwise <c>false</c></returns> public bool GetOrSet(string identifier, out CoreWritingSystemDefinition ws) { lock (m_syncRoot) { if (TryGet(identifier, out ws)) { return(true); } return(Set(identifier, out ws)); } }
public void Load_Empty() { CoreWritingSystemDefinition ws1 = m_wsManager.Create("en"); ValidCharacters validChars = ValidCharacters.Load(ws1); Assert.That(validChars.WordFormingCharacters, Is.Empty); Assert.That(validChars.OtherCharacters, Is.Empty); CoreWritingSystemDefinition ws2 = m_wsManager.Create("en"); validChars.SaveTo(ws2); Assert.That(ws1.ValueEquals(ws2), Is.True); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Sorts the lists. /// </summary> /// ------------------------------------------------------------------------------------ private void InitSortComparer(CoreWritingSystemDefinition ws) { if (m_comparer != null && m_comparer.WritingSystem != ws) { m_comparer = null; } if (m_comparer == null && ws != null) { m_comparer = new TsStringComparer(ws); } }
public void IsWordFormingChar() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ws.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "a", "b", "c", "d", "e", "#" } }); ValidCharacters validChars = ValidCharacters.Load(ws); Assert.IsTrue(validChars.IsWordForming('#')); }
public void CreateAudioWritingSystemVariantFirst() { var wsManager = new WritingSystemManager(); CoreWritingSystemDefinition newWs = wsManager.Create(WellKnownSubtags.UnlistedLanguage, null, null, Enumerable.Empty <VariantSubtag>()); Assert.DoesNotThrow(() => { newWs.Variants.Add(WellKnownSubtags.AudioPrivateUse); newWs.Script = WellKnownSubtags.AudioScript; }); }
public void AddCharacter_SuperscriptedToneNumber() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ValidCharacters validChars = ValidCharacters.Load(ws); var validCharsW = new ValidCharsWrapper(validChars); validChars.AddCharacter("\u00b9"); validChars.AddCharacter("\u2079"); Assert.AreEqual(2, validCharsW.WordFormingCharacters.Count); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("\u00b9")); Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("\u2079")); Assert.AreEqual(0, validCharsW.OtherCharacters.Count); }
/// <summary> /// Gets the specified writing system if it exists. /// </summary> /// <param name="identifier">The identifier.</param> /// <param name="ws">The writing system.</param> /// <returns></returns> public bool TryGet(string identifier, out CoreWritingSystemDefinition ws) { lock (m_syncRoot) { if (Exists(identifier)) { ws = Get(identifier); return(true); } ws = null; return(false); } }
public void Load_AllowGroupedCombiningDiacritics() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ws.CharacterSets.Add(new CharacterSetDefinition("main") { Characters = { "a\u0301" } }); // combining acute accent var validChars = ValidCharacters.Load(ws).WordFormingCharacters.ToList(); Assert.AreEqual(1, validChars.Count); CollectionAssert.Contains(validChars, "a\u0301"); }
private void AddCharactersFromWritingSystem(CoreWritingSystemDefinition ws, string charSetType, ValidCharacterType validCharType) { CharacterSetDefinition charSet; if (!ws.CharacterSets.TryGet(charSetType, out charSet)) { return; } foreach (string chr in charSet.Characters) { AddCharacter(chr, validCharType); } }
public void Load_AllowHardLineBreakCharacter() { CoreWritingSystemDefinition ws1 = m_wsManager.Create("en"); ws1.CharacterSets.Add(new CharacterSetDefinition("punctuation") { Characters = { "\u2028" } }); ValidCharacters validChars = ValidCharacters.Load(ws1); var validCharsW = new ValidCharsWrapper(validChars); Assert.AreEqual(1, validCharsW.OtherCharacters.Count); Assert.IsTrue(validCharsW.OtherCharacters.Contains("\u2028")); }
public void Load_AllowMultigraphs() { CoreWritingSystemDefinition ws1 = m_wsManager.Create("en"); ws1.CharacterSets.Add(new CharacterSetDefinition("punctuation") { Characters = { "Ll", "Sch", "Th" } }); var validChars = ValidCharacters.Load(ws1).OtherCharacters.ToList(); Assert.AreEqual(3, validChars.Count); CollectionAssert.Contains(validChars, "Ll"); CollectionAssert.Contains(validChars, "Sch"); CollectionAssert.Contains(validChars, "Th"); }
public void Load_Empty() { CoreWritingSystemDefinition ws1 = m_wsManager.Create("en"); ValidCharacters validChars = ValidCharacters.Load(ws1, RememberError); var validCharsW = new ValidCharsWrapper(validChars); Assert.That(validCharsW.WordFormingCharacters, Is.Empty); Assert.That(validCharsW.NumericCharacters, Is.Empty); Assert.That(validCharsW.OtherCharacters, Is.Empty); CoreWritingSystemDefinition ws2 = m_wsManager.Create("en"); validChars.SaveTo(ws2); Assert.That(ws1.ValueEquals(ws2), Is.True); Assert.That(m_lastException, Is.Null); }
public void SortAfterAddSingles() { CoreWritingSystemDefinition ws = m_wsManager.Create("en"); ValidCharacters validChars = ValidCharacters.Load(ws); validChars.AddCharacter("z"); validChars.AddCharacter("c"); validChars.AddCharacter("t"); validChars.AddCharacter("b"); validChars.AddCharacter("8"); validChars.AddCharacter("7"); validChars.AddCharacter("6"); validChars.AddCharacter("5"); VerifySortOrder(validChars); }
public void GetNaturalCharType() { CoreWritingSystemDefinition ws = m_wsManager.Create("en-US"); ValidCharacters validChars = ValidCharacters.Load(ws); Assert.AreEqual(ValidCharacterType.WordForming, ReflectionHelper.GetResult(validChars, "GetNaturalCharType", (int)'a')); Assert.AreEqual(ValidCharacterType.WordForming, ReflectionHelper.GetResult(validChars, "GetNaturalCharType", 0x00B2)); Assert.AreEqual(ValidCharacterType.WordForming, ReflectionHelper.GetResult(validChars, "GetNaturalCharType", 0x2079)); Assert.AreEqual(ValidCharacterType.Numeric, ReflectionHelper.GetResult(validChars, "GetNaturalCharType", (int)'1')); Assert.AreEqual(ValidCharacterType.Other, ReflectionHelper.GetResult(validChars, "GetNaturalCharType", (int)' ')); }