public void TestInitializeFromXml_NumericElementClosedTooEarly()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh</WordForming>" +
"<Numeric/>4\uFFFC5" +
"<Other>,\uFFFC!\uFFFC*</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
ValidCharsWrapper 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(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(3, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(","));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("!"));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("*"));
}
public void TestInitializeFromOldValidCharsList()
{
ValidCharacters validChars = ValidCharacters.Load(" a b c d . 1 2 3", "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(4, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("a"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("b"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("c"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("d"));
Assert.AreEqual(3, validCharsW.NumericCharacters.Count);
Assert.IsTrue(validCharsW.NumericCharacters.Contains("1"));
Assert.IsTrue(validCharsW.NumericCharacters.Contains("2"));
Assert.IsTrue(validCharsW.NumericCharacters.Contains("3"));
Assert.AreEqual(2, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(" "));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("."));
string spaceReplacer = ReflectionHelper.GetField(typeof(ValidCharacters),
"kSpaceReplacment") as string;
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming>a\uFFFCb\uFFFCc\uFFFCd</WordForming>" +
"<Numeric>1\uFFFC2\uFFFC3</Numeric>" +
"<Other>" + spaceReplacer + "\uFFFC.</Other>" +
"</ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
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 TestInitializeFromXml_ValidAndBogusCharacters()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>\u05F6\uFFFCg\uFFFC\u05F7\uFFFCh</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
ValidCharsWrapper 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);
Exception e = (Exception)ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException");
Assert.AreEqual("Invalid ValidChars field while loading the xmum (IPA, usa, south) writing system. " +
"The following characters are invalid:" +
Environment.NewLine + "\t\u05F6 (U+05F6)" +
Environment.NewLine + "\t\u05F7 (U+05F7)" +
Environment.NewLine + "Parameter name: xmlSrc",
e.Message);
}
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 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 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("{"));
}
public void InitializeFromXml_ValidAndBogusCharacters()
{
IWritingSystem ws = m_wsManager.Create("en-US");
ws.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>\u05F6\uFFFCg\uFFFC\u05F7\uFFFCh</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(ws, RememberError);
ValidCharsWrapper 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: xmlSrc",
m_lastException.Message);
}
public void AddCharacter_DuplicateOfOverriddenWordFormingChar()
{
string sXml = ksXmlHeader +
"<ValidCharacters><WordForming>a\uFFFC-</WordForming>" +
"<Numeric/>" +
"<Other>{</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper 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("{"));
}
public void InitializeFromXml_ValidNull()
{
var validChars = ValidCharacters.Load(null, "Test WS", null, RememberError, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.IsNull(m_lastException);
}
public void InitializeFromXml_ValidEmptyString()
{
var validChars = ValidCharacters.Load(String.Empty, "Test WS", null, RememberError);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.IsNull(m_lastException);
}
public void TestInitializeFromXml_ValidEmptyString()
{
ValidCharacters validChars = ValidCharacters.Load(String.Empty, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.IsNull(ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException"));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Verifies the default word forming characters.
/// </summary>
/// <param name="validChars">The valid chars.</param>
/// ------------------------------------------------------------------------------------
private static void VerifyDefaultWordFormingCharacters(ValidCharacters validChars)
{
var expectedWordFormingChars = (string[])ReflectionHelper.GetField(
typeof(ValidCharacters), "DefaultWordformingChars");
var validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(expectedWordFormingChars, validCharsW.WordFormingCharacters.ToArray(),
"We expect the load method to have a fallback to the default word-forming characters");
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void TestInitializeFromXml_AllowHardLineBreakCharacter()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming></WordForming>" +
"<Numeric></Numeric>" +
"<Other>\u2028</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(1, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains("\u2028"));
}
public void InitializeFromXml_AllowHardLineBreakCharacter()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming></WordForming>" +
"<Numeric></Numeric>" +
"<Other>\u2028</Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(sXml, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(1, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains("\u2028"));
}
public void InitializeFromNullString()
{
var validChars = ValidCharacters.Load(string.Empty, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming /><Numeric /><Other /></ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void TestInitializeFromNullString()
{
ValidCharacters validChars = ValidCharacters.Load(string.Empty, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming /><Numeric /><Other /></ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void AddCharacter_SuperscriptedToneNumber()
{
ValidCharacters validChars = ValidCharacters.Load(string.Empty, "Test WS", null);
ValidCharsWrapper 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.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
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);
}
public void AddCharacter_SuperscriptedToneNumber()
{
var validChars = ValidCharacters.Load(string.Empty, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper 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.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void InitializeFromXml_SameCharacterInWordFormingAndNumbericXMLLists()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming>1</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(sXml, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(1, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("1"));
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void TestInitializeFromXml_SameCharacterInNumericAndPunctuationXMLLists()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming></WordForming>" +
"<Numeric>1</Numeric>" +
"<Other>1</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(1, validCharsW.NumericCharacters.Count);
Assert.IsTrue(validCharsW.NumericCharacters.Contains("1"));
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
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_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 TestInitializeFromXml_ValidEmpty()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming />" +
"<Numeric />" +
"<Other />" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(sXml,
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
Assert.IsNull(ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException"));
}
public void AddCharacter_Duplicate()
{
ValidCharacters validChars = ValidCharacters.Load(string.Empty, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
validChars.AddCharacter("a");
validChars.AddCharacter("a");
Assert.AreEqual(1, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("a"));
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming>a</WordForming>" +
"<Numeric /><Other /></ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void TestInitializeFromXml_DuplicateCharacters()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming>a\uFFFCa</WordForming>" +
"<Numeric>4\uFFFC4</Numeric>" +
"<Other>'\uFFFC'</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper 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 InitializeFromXml_ValidEmpty()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming />" +
"<Numeric />" +
"<Other />" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(sXml, "Test WS", null, RememberError);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(sXml,
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
Assert.IsNull(m_lastException);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Verifies the sort order of characters added to the specified valid characters
/// object.
/// </summary>
/// ------------------------------------------------------------------------------------
private void VerifySortOrder(ValidCharacters validChars)
{
var validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual("b", validCharsW.WordFormingCharacters[0]);
Assert.AreEqual("c", validCharsW.WordFormingCharacters[1]);
Assert.AreEqual("t", validCharsW.WordFormingCharacters[2]);
Assert.AreEqual("z", validCharsW.WordFormingCharacters[3]);
validChars.AddCharacter("8");
validChars.AddCharacter("7");
validChars.AddCharacter("6");
validChars.AddCharacter("5");
Assert.AreEqual("5", validCharsW.NumericCharacters[0]);
Assert.AreEqual("6", validCharsW.NumericCharacters[1]);
Assert.AreEqual("7", validCharsW.NumericCharacters[2]);
Assert.AreEqual("8", validCharsW.NumericCharacters[3]);
}
public void Load_SameCharacterInWordFormingAndPunctuationLists()
{
CoreWritingSystemDefinition ws = m_wsManager.Create("en-US");
ws.CharacterSets.Add(new CharacterSetDefinition("main")
{
Characters = { "'" }
});
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("'"));
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void AddCharacter_DuplicateOfOverriddenWordFormingChar()
{
string sXml = ksXmlHeader +
"<ValidCharacters><WordForming>a\uFFFC-</WordForming>" +
"<Numeric/>" +
"<Other>{</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper 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("{"));
}
public void AddCharacter_Duplicate()
{
ValidCharacters validChars = ValidCharacters.Load(string.Empty, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
validChars.AddCharacter("a");
validChars.AddCharacter("a");
Assert.AreEqual(1, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("a"));
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming>a</WordForming>" +
"<Numeric /><Other /></ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void TestInitializeFromNullString()
{
ValidCharacters validChars = ValidCharacters.Load(string.Empty, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming /><Numeric /><Other /></ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void TestInitializeFromXml_DuplicateCharacters()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming>a\uFFFCa</WordForming>" +
"<Numeric>4\uFFFC4</Numeric>" +
"<Other>'\uFFFC'</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper 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 TestInitializeFromXml_SameCharacterInNumericAndPunctuationXMLLists()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming></WordForming>" +
"<Numeric>1</Numeric>" +
"<Other>1</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(1, validCharsW.NumericCharacters.Count);
Assert.IsTrue(validCharsW.NumericCharacters.Contains("1"));
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void InitializeFromXml_ValidAndBogusCharacters()
{
IWritingSystem ws = m_wsManager.Create("en-US");
ws.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>\u05F6\uFFFCg\uFFFC\u05F7\uFFFCh</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(ws, RememberError, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper 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: xmlSrc",
m_lastException.Message);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Verifies the default word forming characters.
/// </summary>
/// <param name="validChars">The valid chars.</param>
/// ------------------------------------------------------------------------------------
private static void VerifyDefaultWordFormingCharacters(ValidCharacters validChars)
{
string[] expectedWordFormingChars = (string[])ReflectionHelper.GetField(
typeof(ValidCharacters), "s_defaultWordformingChars");
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(expectedWordFormingChars, validCharsW.WordFormingCharacters.ToArray(),
"We expect the load method to have a fallback to the default word-forming characters");
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void AddCharacter_SuperscriptedToneNumber()
{
var validChars = ValidCharacters.Load(string.Empty, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper 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.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
public void InitializeFromXml_NumericElementClosedTooEarly()
{
var ws = m_wsManager.Create("en-US");
ws.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh</WordForming>" +
"<Numeric/>4\uFFFC5" +
"<Other>,\uFFFC!\uFFFC*</Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(ws, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper 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(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(3, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(","));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("!"));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("*"));
}
public void TestInitializeFromXml_ValidEmpty()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming />" +
"<Numeric />" +
"<Other />" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(sXml,
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
Assert.IsNull(ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException"));
}
public void TestInitializeFromXml_Valid()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh</WordForming>" +
"<Numeric>4\uFFFC5</Numeric>" +
"<Other>,\uFFFC!\uFFFC*</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper 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(2, validCharsW.NumericCharacters.Count);
Assert.IsTrue(validCharsW.NumericCharacters.Contains("4"));
Assert.IsTrue(validCharsW.NumericCharacters.Contains("5"));
Assert.AreEqual(3, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(","));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("!"));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("*"));
Assert.AreEqual(sXml,
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void InitializeFromNullString()
{
var validChars = ValidCharacters.Load(string.Empty, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming /><Numeric /><Other /></ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void AddCharacter_SuperscriptedToneNumber()
{
ValidCharacters validChars = ValidCharacters.Load(string.Empty, "Test WS", null);
ValidCharsWrapper 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.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Verifies the sort order of characters added to the specified valid characters
/// object.
/// </summary>
/// ------------------------------------------------------------------------------------
private void VerifySortOrder(ValidCharacters validChars)
{
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual("b", validCharsW.WordFormingCharacters[0]);
Assert.AreEqual("c", validCharsW.WordFormingCharacters[1]);
Assert.AreEqual("t", validCharsW.WordFormingCharacters[2]);
Assert.AreEqual("z", validCharsW.WordFormingCharacters[3]);
validChars.AddCharacter("8");
validChars.AddCharacter("7");
validChars.AddCharacter("6");
validChars.AddCharacter("5");
Assert.AreEqual("5", validCharsW.NumericCharacters[0]);
Assert.AreEqual("6", validCharsW.NumericCharacters[1]);
Assert.AreEqual("7", validCharsW.NumericCharacters[2]);
Assert.AreEqual("8", validCharsW.NumericCharacters[3]);
}
public void InitializeFromXml_AllowHardLineBreakCharacter()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming></WordForming>" +
"<Numeric></Numeric>" +
"<Other>\u2028</Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(sXml, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(1, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains("\u2028"));
}
public void TestInitializeFromXml_ValidEmptyString()
{
ValidCharacters validChars = ValidCharacters.Load(String.Empty, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.IsNull(ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException"));
}
public void TestInitializeFromXml_ValidAndBogusCharacters()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>\u05F6\uFFFCg\uFFFC\u05F7\uFFFCh</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
ValidCharsWrapper 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);
Exception e = (Exception)ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException");
Assert.AreEqual("Invalid ValidChars field while loading the xmum (IPA, usa, south) writing system. " +
"The following characters are invalid:" +
Environment.NewLine + "\t\u05F6 (U+05F6)" +
Environment.NewLine + "\t\u05F7 (U+05F7)" +
Environment.NewLine + "Parameter name: xmlSrc",
e.Message);
}
public void TestInitializeFromXml_AllowHardLineBreakCharacter()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming></WordForming>" +
"<Numeric></Numeric>" +
"<Other>\u2028</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(sXml, "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(1, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains("\u2028"));
}
public void TestInitializeFromXml_NumericElementClosedTooEarly()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh</WordForming>" +
"<Numeric/>4\uFFFC5" +
"<Other>,\uFFFC!\uFFFC*</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
ValidCharsWrapper 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(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(3, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(","));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("!"));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("*"));
}
public void InitializeFromXml_ValidEmpty()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming />" +
"<Numeric />" +
"<Other />" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(sXml, "Test WS", null, RememberError, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.AreEqual(sXml,
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
Assert.IsNull(m_lastException);
}
public void InitializeFromXml_ValidEmptyString()
{
var validChars = ValidCharacters.Load(String.Empty, "Test WS", null, RememberError, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(0, validCharsW.WordFormingCharacters.Count);
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Assert.IsNull(m_lastException);
}
public void TestInitializeFromOldValidCharsList()
{
ValidCharacters validChars = ValidCharacters.Load(" a b c d . 1 2 3", "Test WS", null);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(4, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("a"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("b"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("c"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("d"));
Assert.AreEqual(3, validCharsW.NumericCharacters.Count);
Assert.IsTrue(validCharsW.NumericCharacters.Contains("1"));
Assert.IsTrue(validCharsW.NumericCharacters.Contains("2"));
Assert.IsTrue(validCharsW.NumericCharacters.Contains("3"));
Assert.AreEqual(2, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(" "));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("."));
string spaceReplacer = ReflectionHelper.GetField(typeof(ValidCharacters),
"kSpaceReplacment") as string;
Assert.AreEqual(ksXmlHeader +
"<ValidCharacters><WordForming>a\uFFFCb\uFFFCc\uFFFCd</WordForming>" +
"<Numeric>1\uFFFC2\uFFFC3</Numeric>" +
"<Other>" + spaceReplacer + "\uFFFC.</Other>" +
"</ValidCharacters>",
validChars.XmlString.Replace(Environment.NewLine, string.Empty).Replace("> <", "><"));
}
public void InitializeFromXml_SameCharacterInWordFormingAndNumbericXMLLists()
{
string sXml = ksXmlHeader + "<ValidCharacters><WordForming>1</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
var validChars = ValidCharacters.Load(sXml, "Test WS", null, null, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(1, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("1"));
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
}
