public void ReadWindowsLcid()
{
var ldmlAdaptor = new LdmlDataMapper();
var wsFromLdml = new WritingSystemDefinition();
using (var tempFile = new TempFile())
{
using (var writer = new StreamWriter(tempFile.Path, false, Encoding.UTF8))
{
writer.Write(
@"<?xml version='1.0' encoding='utf-8'?>
<ldml>
<identity>
<version
number='' />
<language
type='qaa' />
<variant
type='x-lel' />
</identity>
<collations />
<special xmlns:fw='urn://fieldworks.sil.org/ldmlExtensions/v1'>
<fw:graphiteEnabled
value='False' />
<fw:windowsLCID
value='1036' />
</special>
</ldml>".Replace("'", "\""));
}
ldmlAdaptor.Read(tempFile.Path, wsFromLdml);
}
Assert.That(wsFromLdml.WindowsLcid, Is.EqualTo("1036"));
}
public void ReadFromFile_NullFileName_Throws()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
Assert.Throws<ArgumentNullException>(
() => adaptor.Read((string)null, CreateWritingSystem())
);
}
public void Write(XmlWriter writer)
{
switch (_nodeType)
{
case XmlNodeType.Element:
writer.WriteStartElement(_name);
foreach (IcuDataObject ido in _children)
{
ido.Write(writer);
}
writer.WriteEndElement();
break;
case XmlNodeType.Attribute:
writer.WriteAttributeString(_name, _value);
break;
case XmlNodeType.Text:
LdmlDataMapper.WriteLdmlText(writer, _value);
break;
default:
Debug.Assert(false, "Unhandled Icu Data Object type");
break;
}
}
public void ReadFromFile_NullWritingSystem_Throws()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
Assert.Throws<ArgumentNullException>(
() => adaptor.Read("foo.ldml", null)
);
}
public void ReadFromXmlReader_NullXmlReader_Throws()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
Assert.Throws<ArgumentNullException>(
() => adaptor.Read((XmlReader)null, CreateWritingSystem())
);
}
public void ReadFromXmlReader_NullWritingSystem_Throws()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
Assert.Throws<ArgumentNullException>(
() => adaptor.Read(XmlReader.Create(new StringReader("<ldml/>")), null)
);
}
//WS-33992
public void Read_LdmlContainsEmptyCollationElement_SortUsingIsSetToSameAsIfNoCollationElementExisted()
{
const string ldmlWithEmptyCollationElement = "<ldml><!--Comment--><identity><version number=\"\" /><generation date=\"0001-01-01T00:00:00\" /><language type=\"qaa\" /></identity><dates /><collations><collation></collation></collations><special xmlns:palaso=\"urn://palaso.org/ldmlExtensions/v1\" ><palaso:version value=\"2\" /></special></ldml>";
const string ldmlwithNoCollationElement = "<ldml><!--Comment--><identity><version number=\"\" /><generation date=\"0001-01-01T00:00:00\" /><language type=\"qaa\" /></identity><dates /><collations/><special xmlns:palaso=\"urn://palaso.org/ldmlExtensions/v1\" ><palaso:version value=\"2\" /></special></ldml>";
string pathToLdmlWithEmptyCollationElement = Path.GetTempFileName();
try
{
File.WriteAllText(pathToLdmlWithEmptyCollationElement, ldmlWithEmptyCollationElement);
string pathToLdmlWithNoCollationElement = Path.GetTempFileName();
try
{
File.WriteAllText(pathToLdmlWithNoCollationElement, ldmlwithNoCollationElement);
var adaptor = new LdmlDataMapper();
var wsFromEmptyCollationElement = new WritingSystemDefinition();
adaptor.Read(pathToLdmlWithEmptyCollationElement, wsFromEmptyCollationElement);
var wsFromNoCollationElement = new WritingSystemDefinition();
adaptor.Read(pathToLdmlWithNoCollationElement, wsFromNoCollationElement);
Assert.AreEqual(wsFromNoCollationElement.SortUsing, wsFromEmptyCollationElement.SortUsing);
}
finally
{
File.Delete(pathToLdmlWithNoCollationElement);
}
}
finally
{
File.Delete(pathToLdmlWithEmptyCollationElement);
}
}
public void RoundTrippingLdmlDoesNotDuplicateSections()
{
using (var roundTripOut2 = new TempFile())
using (var roundTripOut = new TempFile())
using (var tempFile = new TempFile())
{
using (var writer = new StreamWriter(tempFile.Path, false, Encoding.UTF8))
{
writer.Write(
@"<?xml version='1.0' encoding='utf-8'?>
<ldml>
<identity>
<version
number='' />
<language
type='qaa' />
<variant
type='x-lel' />
</identity>
<collations />
<special xmlns:fw='urn://fieldworks.sil.org/ldmlExtensions/v1'>
<fw:graphiteEnabled
value='False' />
<fw:windowsLCID
value='1036' />
</special>
</ldml>".Replace("'", "\""));
}
var ws = new WritingSystemDefinition();
var dataMapper = new LdmlDataMapper();
dataMapper.Read(tempFile.Path, ws);
var keyboard1 = new DefaultKeyboardDefinition();
keyboard1.Locale = "en-US";
keyboard1.Layout = "MyFavoriteKeyboard";
keyboard1.OperatingSystem = PlatformID.MacOSX; // pick something that for sure won't be our default
ws.AddKnownKeyboard(keyboard1);
using (var fileStream = new FileStream(tempFile.Path, FileMode.Open))
{
dataMapper.Write(roundTripOut.Path, ws, fileStream);
}
AssertThatXmlIn.File(roundTripOut.Path).HasSpecifiedNumberOfMatchesForXpath("/ldml/special/*[local-name()='windowsLCID']", 1);
var secondTripMapper = new LdmlDataMapper();
var secondTripWs = new WritingSystemDefinition();
secondTripMapper.Read(roundTripOut.Path, secondTripWs);
secondTripWs.AddKnownKeyboard(new DefaultKeyboardDefinition()
{
Locale = "qaa",
Layout = "x-tel",
OperatingSystem = PlatformID.Xbox
});
secondTripWs.WindowsLcid = "1037";
using (var fileStream = new FileStream(roundTripOut.Path, FileMode.Open))
{
secondTripMapper.Write(roundTripOut2.Path, secondTripWs, fileStream);
}
AssertThatXmlIn.File(roundTripOut2.Path).HasSpecifiedNumberOfMatchesForXpath("/ldml/special/*[local-name()='windowsLCID']", 1); //Element duplicated on round trip
}
}
public void Read_ValidLanguageTagStartingWithXButVersion0_Throws()
{
using (var file = new TempFile())
{
WriteVersion0Ldml("xh", "", "", "", file);
var adaptor = new LdmlDataMapper();
Assert.That(() => adaptor.Read(file.Path, new WritingSystemDefinition()), Throws.Exception.TypeOf <ApplicationException>());
}
}
public void WriteRoundTrip_LdmlIsFlexPrivateUseFormat_LdmlIsUnchanged()
{
using (var file = new TempFile())
{
WriteVersion0Ldml("x-en", "", "", "", file);
var adaptor = new LdmlDataMapper();
var ws = new WritingSystemDefinition();
adaptor.Read(file.Path, ws);
adaptor.Write(file.Path, ws, new MemoryStream(File.ReadAllBytes(file.Path), true), WritingSystemCompatibility.Flex7V0Compatible);
AssertThatLdmlMatches("x-en", "", "", "", file);
}
}
private WritingSystemDefinition GetWritingSystemFromLdml(string filePath)
{
var ws = (WritingSystemDefinition)CreateNew();
LdmlDataMapper adaptor = CreateLdmlAdaptor();
if (File.Exists(filePath))
{
adaptor.Read(filePath, ws);
ws.StoreID = Path.GetFileNameWithoutExtension(filePath);
}
return(ws);
}
public void WriteNoRoundTrip_LdmlIsFlexPrivateUseFormatlanguageAndScript_LdmlIsChanged()
{
using (var file = new TempFile())
{
WriteVersion0Ldml("x-en", "Zxxx", "", "", file);
var adaptor = new LdmlDataMapper();
var ws = new WritingSystemDefinition();
adaptor.Read(file.Path, ws);
adaptor.Write(file.Path, ws, new MemoryStream(File.ReadAllBytes(file.Path), false), WritingSystemCompatibility.Strict);
AssertThatLdmlMatches("qaa", "Zxxx", "", "x-en", file);
}
}
public void SaveAllDefinitions(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("writingsystems");
foreach (WritingSystemDefinition ws in AllWritingSystems)
{
LdmlDataMapper adaptor = CreateLdmlAdaptor();
adaptor.Write(xmlWriter, ws, null);
}
xmlWriter.WriteEndElement();
//delete anything we're going to delete first, to prevent loosing
//a WS we want by having it deleted by an old WS we don't want
//(but which has the same identifier)
}
public void WriteRoundTrip_LdmlIsValidLanguageStartingWithX_LdmlIsUnchanged()
{
using (var file = new TempFile())
{
WriteVersion2Ldml("xh", "", "", "", file);
var adaptor = new LdmlDataMapper();
var ws = new WritingSystemDefinition();
adaptor.Read(file.Path, ws);
adaptor.Write(file.Path, ws, new MemoryStream(File.ReadAllBytes(file.Path), true), WritingSystemCompatibility.Flex7V0Compatible);
AssertThatLdmlMatches("xh", "", "", "", file);
AssertThatVersionIs(2, file);
}
}
public void Read_V0Ldml_ThrowFriendlyException()
{
using (var file = new TempFile())
{
WriteVersion0Ldml("en", "", "", "", file);
var ws = new WritingSystemDefinition();
var dataMapper = new LdmlDataMapper();
Assert.That(() => dataMapper.Read(file.Path, ws),
Throws.Exception.TypeOf <ApplicationException>()
.With.Property("Message")
.EqualTo(String.Format("The LDML tag 'en' is version 0. Version {1} was expected.", file.Path,
WritingSystemDefinition.LatestWritingSystemDefinitionVersion)));
}
}
public void RoundTripFlexPrivateUseWritingSystem_LanguageAndPrivateUsePopulated()
{
using (var file = new TempFile())
{
WriteVersion0Ldml("x-en", "", "", "x-private", file);
var ws = new WritingSystemDefinition();
string originalLdml = File.ReadAllText(file.Path);
var adaptor = new LdmlDataMapper();
adaptor.Read(file.Path, ws);
AssertThatRfcTagComponentsOnWritingSystemAreEqualTo(ws, "", "", "", "x-en-private");
adaptor.Write(file.Path, ws, new MemoryStream(File.ReadAllBytes(file.Path)), WritingSystemCompatibility.Flex7V0Compatible);
Assert.That(File.ReadAllText(file.Path), Is.EqualTo(originalLdml));
}
}
public void Write_OriginalWasFlexPrivateUseWritingSystemButNowChangedPrivateUse_IdentityElementChangedToPalasoWay()
{
using (var file = new TempFile())
{
WriteVersion0Ldml("x-en", "", "", "x-private", file);
var ws = new WritingSystemDefinition();
var adaptor = new LdmlDataMapper();
adaptor.Read(file.Path, ws);
AssertThatRfcTagComponentsOnWritingSystemAreEqualTo(ws, "", "", "", "x-en-private");
ws.Variant = "x-en-changed";
adaptor.Write(file.Path, ws, new MemoryStream(File.ReadAllBytes(file.Path)));
AssertThatLdmlMatches("", "", "", "x-en-changed", file);
}
}
private WritingSystemDefinition LoadWritingSystemDefinition()
{
if (!ContainsLdmlFile())
{
return(null);
}
var ldmlAdaptor = new LdmlDataMapper(new WritingSystemFactory());
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(LdmlFilePath, wsFromLdml);
return(wsFromLdml);
}
public void LoadAllDefinitions(XmlReader xmlReader)
{
LdmlDataMapper adaptor = CreateLdmlAdaptor();
// Check the current node, it should be 'writingsystems'
if ("writingsystems" == xmlReader.Name)
{
while (xmlReader.ReadToFollowing("ldml"))
{
var ws = (WritingSystemDefinition)CreateNew();
adaptor.Read(xmlReader.ReadSubtree(), ws);
ws.StoreID = ws.Bcp47Tag;
Set(ws);
}
}
}
public void Read_ReadPrivateUseWsFromFieldWorksLdmlThenNormalLdmlMissingVersion1Element_Throws()
{
using (var badFlexLdml = new TempFile())
{
using (var version1Ldml = new TempFile())
{
WriteVersion0Ldml("x-en", "", "", "x-private", badFlexLdml);
WriteVersion0Ldml("en", "", "", "", version1Ldml);
var wsV1 = new WritingSystemDefinition();
var wsV0 = new WritingSystemDefinition();
var adaptor = new LdmlDataMapper();
adaptor.Read(badFlexLdml.Path, wsV0);
Assert.Throws <ApplicationException>(() => adaptor.Read(version1Ldml.Path, wsV1));
}
}
}
public void LoadAllDefinitions(string filePath)
{
XPathDocument xpDoc = new XPathDocument(new StreamReader(filePath));
XPathNavigator xpNav = xpDoc.CreateNavigator();
XPathNodeIterator nodes = xpNav.Select("//writingsystems/ldml");
LdmlDataMapper adaptor = CreateLdmlAdaptor();
foreach (XPathNavigator nav in nodes)
{
var ws = (WritingSystemDefinition)CreateNew();
XmlReader xmlReader = nav.ReadSubtree();
adaptor.Read(xmlReader, ws);
ws.StoreID = ws.Bcp47Tag;
Set(ws);
}
}
private void LoadLdml(string path, string iso)
{
if (WritingSystem.Language == iso)
{
return;
}
var ldmlFilePath = Path.Combine(path, iso + ".ldml");
if (!System.IO.File.Exists(ldmlFilePath))
{
WritingSystem.DefaultFont = new FontDefinition("Charis SIL");
return;
}
var ldmlAdaptor = new LdmlDataMapper(new WritingSystemFactory());
ldmlAdaptor.Read(ldmlFilePath, WritingSystem);
}
public void RoundtripKnownKeyboards()
{
var ldmlAdaptor = new LdmlDataMapper();
Keyboard.Controller = new MyKeyboardController();
const string sortRules = "(A̍ a̍)";
var wsWithKnownKeyboards = new WritingSystemDefinition();
var keyboard1 = new DefaultKeyboardDefinition();
keyboard1.Locale = "en-US";
keyboard1.Layout = "MyFavoriteKeyboard";
keyboard1.OperatingSystem = PlatformID.MacOSX; // pick something that for sure won't be our default
wsWithKnownKeyboards.AddKnownKeyboard(keyboard1);
var keyboard2 = new DefaultKeyboardDefinition();
keyboard2.Locale = "en-GB";
keyboard2.Layout = "SusannasFavoriteKeyboard";
keyboard2.OperatingSystem = PlatformID.Unix;
wsWithKnownKeyboards.AddKnownKeyboard(keyboard2);
var wsFromLdml = new WritingSystemDefinition();
using (var tempFile = new TempFile())
{
ldmlAdaptor.Write(tempFile.Path, wsWithKnownKeyboards, null);
ldmlAdaptor.Read(tempFile.Path, wsFromLdml);
}
var knownKeyboards = wsFromLdml.KnownKeyboards.ToList();
Assert.That(knownKeyboards, Has.Count.EqualTo(2), "restored WS should have known keyboards");
var keyboard1FromLdml = knownKeyboards[0];
Assert.That(keyboard1FromLdml.Layout, Is.EqualTo("MyFavoriteKeyboard"));
Assert.That(keyboard1FromLdml.Locale, Is.EqualTo("en-US"));
Assert.That(keyboard1FromLdml.OperatingSystem, Is.EqualTo(PlatformID.MacOSX));
Assert.That(keyboard1FromLdml, Is.InstanceOf <MyKeyboardDefn>(), "Reader should have used controller to create keyboard defn");
var keyboard2FromLdml = knownKeyboards[1];
Assert.That(keyboard2FromLdml.Layout, Is.EqualTo("SusannasFavoriteKeyboard"));
Assert.That(keyboard2FromLdml.Locale, Is.EqualTo("en-GB"));
Assert.That(keyboard2FromLdml.OperatingSystem, Is.EqualTo(PlatformID.Unix));
}
public void Write_WritingSystemWasloadedFromLdmlThatContainedLayoutInfo_LayoutInfoIsOnlyWrittenOnce()
{
using (var file = new TempFile())
{
//create an ldml file to read that contains layout info
var adaptor = new LdmlDataMapper();
var ws = WritingSystemDefinition.Parse("en-Zxxx-x-audio");
ws.RightToLeftScript = true;
adaptor.Write(file.Path, ws, null);
//read the file and write it out unchanged
var ws2 = new WritingSystemDefinition();
adaptor.Read(file.Path, ws2);
adaptor.Write(file.Path, ws2, new MemoryStream(File.ReadAllBytes(file.Path)));
AssertThatXmlIn.File(file.Path).HasNoMatchForXpath("/ldml/layout[2]");
}
}
private void WriteLdmlFile(string filePath, IEnumerable <WritingSystemDefinition> writingSystems)
{
XmlWriter xmlWriter = new XmlTextWriter(filePath, System.Text.Encoding.UTF8);
xmlWriter.WriteStartDocument();
xmlWriter.WriteStartElement("someroot");
xmlWriter.WriteStartElement("writingsystems");
var adaptor = new LdmlDataMapper(_writingSystemRepository.WritingSystemFactory);
foreach (WritingSystemDefinition ws in writingSystems)
{
adaptor.Write(xmlWriter, ws, null);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
xmlWriter.Close();
}
public void Write_WritePrivateUseWsFromFieldWorksLdmlThenNormalLdml_ContainsVersion1()
{
using (var badFlexLdml = new TempFile())
{
using (var version1Ldml = new TempFile())
{
var namespaceManager = new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace("palaso", "urn://palaso.org/ldmlExtensions/v1");
WriteVersion0Ldml("x-en", "", "", "x-private", badFlexLdml);
var wsV0 = new WritingSystemDefinition();
var adaptor = new LdmlDataMapper();
adaptor.Read(badFlexLdml.Path, wsV0);
adaptor.Write(badFlexLdml.Path, wsV0, new MemoryStream(File.ReadAllBytes(badFlexLdml.Path)));
var wsV1 = new WritingSystemDefinition();
adaptor.Write(version1Ldml.Path, wsV1, null);
AssertThatVersionIs(2, version1Ldml);
}
}
}
public void RoundtripSimpleCustomSortRules_WS33715()
{
var ldmlAdaptor = new LdmlDataMapper();
const string sortRules = "(A̍ a̍)";
var wsWithSimpleCustomSortRules = new WritingSystemDefinition();
wsWithSimpleCustomSortRules.SortUsing = WritingSystemDefinition.SortRulesType.CustomSimple;
wsWithSimpleCustomSortRules.SortRules = sortRules;
var wsFromLdml = new WritingSystemDefinition();
using (var tempFile = new TempFile())
{
ldmlAdaptor.Write(tempFile.Path, wsWithSimpleCustomSortRules, null);
ldmlAdaptor.Read(tempFile.Path, wsFromLdml);
}
Assert.AreEqual(sortRules, wsFromLdml.SortRules);
}
public void SaveDefinition(WritingSystemDefinition ws)
{
Set(ws);
string writingSystemFilePath = GetFilePathFromIdentifier(ws.StoreID);
MemoryStream oldData = null;
if (!ws.Modified && File.Exists(writingSystemFilePath))
{
return; // no need to save (better to preserve the modified date)
}
if (File.Exists(writingSystemFilePath))
{
// load old data to preserve stuff in LDML that we don't use, but don't throw up an error if it fails
try
{
oldData = new MemoryStream(File.ReadAllBytes(writingSystemFilePath), false);
}
catch {}
// What to do? Assume that the UI has already checked for existing, asked, and allowed the overwrite.
File.Delete(writingSystemFilePath); //!!! Should this be move to trash?
}
LdmlDataMapper adaptor = CreateLdmlAdaptor();
adaptor.Write(writingSystemFilePath, ws, oldData);
ws.Modified = false;
if (_idChangeMap.Any(p => p.Value == ws.StoreID))
{
// log this id change to the writing system change log
var pair = _idChangeMap.First(p => p.Value == ws.StoreID);
_changeLog.LogChange(pair.Key, pair.Value);
}
else
{
// log this addition
_changeLog.LogAdd(ws.StoreID);
}
}
public void Read_LdmlContainsOnlyPrivateUse_IsoAndprivateUseSetCorrectly()
{
const string ldmlWithOnlyPrivateUse = "<ldml><identity><version number=\"\" /><language type=\"\" /><variant type=\"x-private-use\" /></identity><special xmlns:palaso=\"urn://palaso.org/ldmlExtensions/v1\" ><palaso:version value=\"2\" /></special></ldml>";
string pathToLdmlWithEmptyCollationElement = Path.GetTempFileName();
try
{
File.WriteAllText(pathToLdmlWithEmptyCollationElement, ldmlWithOnlyPrivateUse);
var adaptor = new LdmlDataMapper();
var wsFromLdml = new WritingSystemDefinition();
adaptor.Read(pathToLdmlWithEmptyCollationElement, wsFromLdml);
var ws = new WritingSystemDefinition();
adaptor.Read(pathToLdmlWithEmptyCollationElement, ws);
Assert.That(wsFromLdml.Language, Is.EqualTo(String.Empty));
Assert.That(wsFromLdml.Variant, Is.EqualTo("x-private-use"));
}
finally
{
File.Delete(pathToLdmlWithEmptyCollationElement);
}
}
public void RoundtripSimpleCustomSortRules_WS33715()
{
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
const string sortRules = "(A̍ a̍)";
var cd = new SimpleRulesCollationDefinition("standard") {SimpleRules = sortRules};
var wsWithSimpleCustomSortRules = new WritingSystemDefinition();
wsWithSimpleCustomSortRules.Collations.Add(cd);
var wsFromLdml = new WritingSystemDefinition();
using (var tempFile = new TempFile())
{
ldmlAdaptor.Write(tempFile.Path, wsWithSimpleCustomSortRules, null);
ldmlAdaptor.Read(tempFile.Path, wsFromLdml);
}
var cdFromLdml = (SimpleRulesCollationDefinition) wsFromLdml.Collations.First();
Assert.AreEqual(sortRules, cdFromLdml.SimpleRules);
}
public void Roundtrip_LdmlSimpleCollationNeedsCompiling()
{
using (var environment = new TestEnvironment())
{
const string simpleRules =
"\r\n\t\t\t\t\t\\!/A\r\n\t\t\t\t\tb/B\r\n\t\t\t\t\tt/T\r\n\t\t\t\t\ts/S\r\n\t\t\t\t\tc/C\r\n\t\t\t\t\tk/K\r\n\t\t\t\t\tx/X\r\n\t\t\t\t\ti/I\r\n\t\t\t\t\td/D\r\n\t\t\t\t\tq/Q\r\n\t\t\t\t\tr/R\r\n\t\t\t\t\te/E\r\n\t\t\t\t\tf/F\r\n\t\t\t\t\tg/G\r\n\t\t\t\t\to/O\r\n\t\t\t\t\tj/J\r\n\t\t\t\t\tl/L\r\n\t\t\t\t\tm/M\r\n\t\t\t\t\tn/N\r\n\t\t\t\t\tp/P\r\n\t\t\t\t\tu/U\r\n\t\t\t\t\tv/V\r\n\t\t\t\t\tw/W\r\n\t\t\t\t\th/H\r\n\t\t\t\t\ty/Y\r\n\t\t\t\t\tz/Z\r\n\t\t\t\t";
var cd = new SimpleRulesCollationDefinition("standard")
{
SimpleRules = simpleRules,
};
var wsToLdml = new WritingSystemDefinition("aa", "Latn", "", "");
wsToLdml.Collations.Add(cd);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
XElement ldmlElem = XElement.Load(environment.FilePath("test.ldml"));
XElement collationsElem = ldmlElem.Element("collations");
XElement defaultCollationElem = collationsElem.Element("defaultCollation");
XElement collationElem = collationsElem.Element("collation");
XElement specialElem = collationElem.Element("special");
XElement simpleElem = specialElem.Element(Sil + "simple");
Assert.That((string)defaultCollationElem, Is.EqualTo("standard"));
Assert.That((string)collationElem.Attribute("type"), Is.EqualTo("standard"));
Assert.That((string)specialElem.Attribute(Sil + "needsCompiling"), Is.EqualTo("true"));
Assert.That((string)simpleElem, Is.EqualTo(simpleRules.Replace("\r\n", "\n")));
var validatedCd = new SimpleRulesCollationDefinition("standard")
{
SimpleRules = simpleRules
};
// When the LDML reader parses the invalid rules, it will validate and regenerate icu rules
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.Collations.First().ValueEquals(validatedCd));
Assert.That(wsFromLdml.DefaultCollation.ValueEquals(validatedCd));
}
}
public void Roundtrip_LdmlSimpleCollation()
{
using (var environment = new TestEnvironment())
{
const string simpleRules =
"\r\n\t\t\t\t\ta/A\r\n\t\t\t\t\tb/B\r\n\t\t\t\t\tt/T\r\n\t\t\t\t\ts/S\r\n\t\t\t\t\tc/C\r\n\t\t\t\t\tk/K\r\n\t\t\t\t\tx/X\r\n\t\t\t\t\ti/I\r\n\t\t\t\t\td/D\r\n\t\t\t\t\tq/Q\r\n\t\t\t\t\tr/R\r\n\t\t\t\t\te/E\r\n\t\t\t\t\tf/F\r\n\t\t\t\t\tg/G\r\n\t\t\t\t\to/O\r\n\t\t\t\t\tj/J\r\n\t\t\t\t\tl/L\r\n\t\t\t\t\tm/M\r\n\t\t\t\t\tn/N\r\n\t\t\t\t\tp/P\r\n\t\t\t\t\tu/U\r\n\t\t\t\t\tv/V\r\n\t\t\t\t\tw/W\r\n\t\t\t\t\th/H\r\n\t\t\t\t\ty/Y\r\n\t\t\t\t\tz/Z\r\n\t\t\t\t";
const string icuRules =
"&[before 1] [first regular] < a\\/A < b\\/B < t\\/T < s\\/S < c\\/C < k\\/K < x\\/X < i\\/I < d\\/D < q\\/Q < r\\/R < e\\/E < f\\/F < g\\/G < o\\/O < j\\/J < l\\/L < m\\/M < n\\/N < p\\/P < u\\/U < v\\/V < w\\/W < h\\/H < y\\/Y < z\\/Z";
var cd = new SimpleRulesCollationDefinition("standard")
{
SimpleRules = simpleRules,
CollationRules = icuRules,
IsValid = true
};
var wsToLdml = new WritingSystemDefinition("aa", "Latn", "", "");
wsToLdml.Collations.Add(cd);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
XElement ldmlElem = XElement.Load(environment.FilePath("test.ldml"));
XElement collationsElem = ldmlElem.Element("collations");
XElement defaultCollationElem = collationsElem.Element("defaultCollation");
XElement collationElem = collationsElem.Element("collation");
XElement crElem = collationElem.Element("cr");
XElement simpleElem = collationElem.Element("special").Element(Sil + "simple");
Assert.That((string)defaultCollationElem, Is.EqualTo("standard"));
Assert.That((string)collationElem.Attribute("type"), Is.EqualTo("standard"));
Assert.That((string)crElem, Is.EqualTo(icuRules.Replace("\r\n", "\n")));
Assert.That((string)simpleElem, Is.EqualTo(simpleRules.Replace("\r\n", "\n")));
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.Collations.First().ValueEquals(cd));
Assert.That(wsFromLdml.DefaultCollation.ValueEquals(cd));
}
}
public void Roundtrip_LdmlInvalidStandardCollation()
{
using (var environment = new TestEnvironment())
{
const string icuRules =
"&&&B<t<<<T<s<<<S<e<<<E\r\n\t\t\t\t&C<k<<<K<x<<<X<i<<<I\r\n\t\t\t\t&D<q<<<Q<r<<<R\r\n\t\t\t\t&G<o<<<O\r\n\t\t\t\t&W<h<<<H";
var cd = new IcuRulesCollationDefinition("standard")
{
IcuRules = icuRules,
CollationRules = icuRules,
IsValid = false
};
var wsToLdml = new WritingSystemDefinition("aa", "Latn", "", "");
wsToLdml.Collations.Add(cd);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
XElement ldmlElem = XElement.Load(environment.FilePath("test.ldml"));
XElement collationsElem = ldmlElem.Element("collations");
XElement defaultCollationElem = collationsElem.Element("defaultCollation");
XElement collationElem = collationsElem.Element("collation");
Assert.That((string)defaultCollationElem, Is.EqualTo("standard"));
Assert.That((string)collationElem.Attribute("type"), Is.EqualTo("standard"));
Assert.That((string)collationElem, Is.EqualTo(icuRules.Replace("\r\n", "\n")));
// Verify comment written about being unable to parse ICU rule
const string expectedComment = "'Unable to parse the ICU rules with ICU version'";
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath(string.Format("/ldml/collations/collation/comment()[contains(.,{0})]", expectedComment));
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.Collations.First().ValueEquals(cd));
}
}
public void Roundtrip_LdmlDelimiters()
{
using (var environment = new TestEnvironment())
{
var mp = new MatchedPair("mpOpen1", "mpClose2", false);
var pp = new PunctuationPattern("pattern1", PunctuationPatternContext.Medial);
// Quotation Marks:
// Level 1 normal quotation marks (quotationStart and quotationEnd)
// Level 2 normal quotation marks (alternateQuotationStart and alternateQuotationEnd)
// Level 3 normal quotation marks (special: sil:quotation-marks)
// Level 1 narrative quotation marks (special: sil:quotation-marks)
var qm1 = new QuotationMark("\"", "\"", "\"", 1, QuotationMarkingSystemType.Normal);
var qm2 = new QuotationMark("{", "}", "{", 2, QuotationMarkingSystemType.Normal);
var qm3 = new QuotationMark("open1", "close2", "cont3", 3, QuotationMarkingSystemType.Normal);
var qm4 = new QuotationMark("", null, null, 1, QuotationMarkingSystemType.Narrative);
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.MatchedPairs.Add(mp);
wsToLdml.PunctuationPatterns.Add(pp);
wsToLdml.QuotationMarks.Add(qm1);
wsToLdml.QuotationMarks.Add(qm2);
wsToLdml.QuotationMarks.Add(qm3);
wsToLdml.QuotationMarks.Add(qm4);
wsToLdml.QuotationParagraphContinueType = QuotationParagraphContinueType.Outermost;
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:matched-pairs/sil:matched-pair[@open='mpOpen1' and @close='mpClose2' and @paraClose='false']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:punctuation-patterns/sil:punctuation-pattern[@pattern='pattern1' and @context='medial']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/quotationStart[text()='\"']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/quotationEnd[text()='\"']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/alternateQuotationStart[text()='{']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/alternateQuotationEnd[text()='}']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:quotationContinue[text()='\"']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:alternateQuotationContinue[text()='{']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:quotation[@open='open1' and @close='close2' and @continue='cont3' and @level='3']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:quotation[@open and string-length(@open)=0 and @level='1' and @type='narrative']", 1, environment.NamespaceManager);
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.MatchedPairs.FirstOrDefault(), Is.EqualTo(mp));
Assert.That(wsFromLdml.PunctuationPatterns.FirstOrDefault(), Is.EqualTo(pp));
Assert.That(wsFromLdml.QuotationParagraphContinueType, Is.EqualTo(QuotationParagraphContinueType.Outermost));
Assert.That(wsFromLdml.QuotationMarks[0], Is.EqualTo(qm1));
Assert.That(wsFromLdml.QuotationMarks[1], Is.EqualTo(qm2));
Assert.That(wsFromLdml.QuotationMarks[2], Is.EqualTo(qm3));
Assert.That(wsFromLdml.QuotationMarks[3], Is.EqualTo(qm4));
// Test rewriting the loaded file while using the original version as a base to make sure
// no duplicate elements are created
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsFromLdml, new MemoryStream(File.ReadAllBytes(environment.FilePath("test.ldml"))));
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:matched-pairs/sil:matched-pair[@open='mpOpen1' and @close='mpClose2' and @paraClose='false']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:punctuation-patterns/sil:punctuation-pattern[@pattern='pattern1' and @context='medial']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/quotationStart[text()='\"']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/quotationEnd[text()='\"']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/alternateQuotationStart[text()='{']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/alternateQuotationEnd[text()='}']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:quotationContinue[text()='\"']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:alternateQuotationContinue[text()='{']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:quotation[@open='open1' and @close='close2' and @continue='cont3' and @level='3']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasSpecifiedNumberOfMatchesForXpath("/ldml/delimiters/special/sil:quotation-marks/sil:quotation[@open and string-length(@open)=0 and @level='1' and @type='narrative']", 1, environment.NamespaceManager);
}
}
public void Roundtrip_LdmlStandardCollation()
{
using (var environment = new TestEnvironment())
{
const string icuRules =
"&B<t<<<T<s<<<S<e<<<E\r\n\t\t\t\t&C<k<<<K<x<<<X<i<<<I\r\n\t\t\t\t&D<q<<<Q<r<<<R\r\n\t\t\t\t&G<o<<<O\r\n\t\t\t\t&W<h<<<H";
var cd = new IcuRulesCollationDefinition("standard")
{
IcuRules = icuRules,
CollationRules = icuRules,
IsValid = true
};
var wsToLdml = new WritingSystemDefinition("aa", "Latn", "", "");
wsToLdml.Collations.Add(cd);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
XElement ldmlElem = XElement.Load(environment.FilePath("test.ldml"));
XElement collationsElem = ldmlElem.Element("collations");
XElement defaultCollationElem = collationsElem.Element("defaultCollation");
XElement collationElem = collationsElem.Element("collation");
Assert.That((string)defaultCollationElem, Is.EqualTo("standard"));
Assert.That((string) collationElem.Attribute("type"), Is.EqualTo("standard"));
Assert.That((string) collationElem, Is.EqualTo(icuRules.Replace("\r\n", "\n")));
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.Collations.First().ValueEquals(cd));
}
}
public void Write_SystemCollationDefinition_NotWrittenToLdml()
{
using (var environment = new TestEnvironment())
{
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.DefaultCollation = new SystemCollationDefinition { LanguageTag = "en-US" };
wsToLdml.Collations.Add(new IcuRulesCollationDefinition("standard"));
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath(
"/ldml/collations/collation[@type='standard']",
environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasNoMatchForXpath(
"/ldml/collations/collation[@type='system']",
environment.NamespaceManager);
}
}
public void Write_LdmlIsNicelyFormatted()
{
#if MONO
// mono inserts \r\n\t before xmlns where windows doesn't
string expectedFileContent =
#region filecontent
@"<?xml version='1.0' encoding='utf-8'?>
<ldml>
<identity>
<version
number='' />
<generation
date='0001-01-01T00:00:00' />
<language
type='en' />
<script
type='Zxxx' />
<territory
type='US' />
<variant
type='x-audio' />
</identity>
<collations />
<special
xmlns:palaso='urn://palaso.org/ldmlExtensions/v1'>
<palaso:abbreviation
value='en' />
<palaso:languageName
value='English' />
<palaso:version
value='2' />
</special>
</ldml>".Replace("'", "\"").Replace("\n", "\r\n");
#endregion
#else
string expectedFileContent =
#region filecontent
@"<?xml version='1.0' encoding='utf-8'?>
<ldml>
<identity>
<version
number='' />
<generation
date='0001-01-01T00:00:00' />
<language
type='en' />
<script
type='Zxxx' />
<territory
type='US' />
<variant
type='x-audio' />
</identity>
<collations />
<special xmlns:palaso='urn://palaso.org/ldmlExtensions/v1'>
<palaso:abbreviation
value='en' />
<palaso:languageName
value='English' />
<palaso:version
value='2' />
</special>
</ldml>".Replace("'", "\"").Replace("\n", "\r\n").Replace("\r\r\n", "\r\n");
#endregion
#endif
using (var file = new TempFile())
{
//Create an ldml fiel to read
var adaptor = new LdmlDataMapper();
var ws = WritingSystemDefinition.Parse("en-Zxxx-x-audio");
adaptor.Write(file.Path, ws, null);
//change the read writing system and write it out again
var ws2 = new WritingSystemDefinition();
adaptor.Read(file.Path, ws2);
ws2.Region = "US";
adaptor.Write(file.Path, ws2, new MemoryStream(File.ReadAllBytes(file.Path)));
Assert.That(File.ReadAllText(file.Path), Is.EqualTo(expectedFileContent));
}
}
public void Read_LdmlContainsOnlyPrivateUse_IsoAndprivateUseSetCorrectly()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var wsFromLdml = new WritingSystemDefinition();
using (var tempFile = new TempFile())
{
using (var writer = new StreamWriter(tempFile.Path, false, Encoding.UTF8))
writer.Write(LdmlContentForTests.Version3Identity("", "", "", "x-private-use", "abcdefg", "123456", "private", "", ""));
adaptor.Read(tempFile.Path, wsFromLdml);
Assert.That(wsFromLdml.Variants, Is.EqualTo(new[]
{
new VariantSubtag("private", "private", true, new List<string>()),
new VariantSubtag("use", "", true, new List<string>())
}));
}
}
public void SetUp()
{
_adaptor = new LdmlDataMapper();
_ws = new WritingSystemDefinition("en", "Latn", "US", string.Empty, "eng", false);
}
/// <summary>
/// Writes an LDML representation of this writing system to the specified writer.
/// </summary>
/// <param name="writer">The writer.</param>
public void WriteLdml(XmlWriter writer)
{
var ldmlDataMapper = new LdmlDataMapper(new CoreWritingSystemFactory());
ldmlDataMapper.Write(writer, this, null);
}
public void Roundtrip_LdmlIcuCollationWithImports()
{
using (var environment = new TestEnvironment())
{
const string icuRules =
"&B<t<<<T<s<<<S<e<<<E\n\t\t\t\t&C<k<<<K<x<<<X<i<<<I\n\t\t\t\t&D<q<<<Q<r<<<R\n\t\t\t\t&G<o<<<O\n\t\t\t\t&W<h<<<H";
var cd = new IcuRulesCollationDefinition("standard")
{
Imports = {new IcuCollationImport("my", "standard")},
CollationRules = icuRules,
IsValid = true
};
var wsToLdml = new WritingSystemDefinition("aa", "Latn", "", "");
wsToLdml.Collations.Add(cd);
var wsFactory = new TestWritingSystemFactory {WritingSystems =
{
new WritingSystemDefinition("my")
{
Collations = {new IcuRulesCollationDefinition("standard") {IcuRules = icuRules, CollationRules = icuRules, IsValid = true}}
}
}};
var ldmlAdaptor = new LdmlDataMapper(wsFactory);
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
XElement ldmlElem = XElement.Load(environment.FilePath("test.ldml"));
XElement collationsElem = ldmlElem.Element("collations");
XElement defaultCollationElem = collationsElem.Element("defaultCollation");
XElement collationElem = collationsElem.Element("collation");
XElement crElem = collationElem.Element("cr");
XElement importElem = collationElem.Element("import");
Assert.That((string) defaultCollationElem, Is.EqualTo("standard"));
Assert.That((string) collationElem.Attribute("type"), Is.EqualTo("standard"));
Assert.That(crElem, Is.Null);
Assert.That((string) importElem.Attribute("source"), Is.EqualTo("my"));
Assert.That((string) importElem.Attribute("type"), Is.EqualTo("standard"));
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.Collations.First().ValueEquals(cd));
Assert.That(wsFromLdml.DefaultCollation.ValueEquals(cd));
}
}
public void ExistingUnusedLdml_Write_PreservesData()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var sw = new StringWriter();
var ws = new WritingSystemDefinition("en");
var writer = XmlWriter.Create(sw, CanonicalXmlSettings.CreateXmlWriterSettings());
adaptor.Write(writer, ws, XmlReader.Create(new StringReader("<ldml><!--Comment--><dates/><special>hey</special></ldml>")));
writer.Close();
AssertThatXmlIn.String(sw.ToString()).HasAtLeastOneMatchForXpath("/ldml/special[text()=\"hey\"]");
}
public void Write_LdmlIsNicelyFormatted()
{
using (var file = new TempFile())
{
//Create an ldml file to read
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var ws = new WritingSystemDefinition("en-Zxxx-x-audio");
adaptor.Write(file.Path, ws, null);
//change the read writing system and write it out again
var ws2 = new WritingSystemDefinition();
adaptor.Read(file.Path, ws2);
ws2.Region = "US";
adaptor.Write(file.Path, ws2, new MemoryStream(File.ReadAllBytes(file.Path)));
Assert.That(XElement.Load(file.Path), Is.EqualTo(XElement.Parse(
@"<?xml version='1.0' encoding='utf-8'?>
<ldml>
<identity>
<version number='' />
<generation date='0001-01-01T00:00:00Z' />
<language type='en' />
<script type='Zxxx' />
<territory type='US' />
<variant type='x-audio' />
</identity>
<layout>
<orientation>
<characterOrder>left-to-right</characterOrder>
</orientation>
</layout>
</ldml>"
)).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
}
}
public void WriteRoundTrip_LdmlIsValidLanguageStartingWithX_LdmlIsUnchanged()
{
using (var file = new TempFile())
{
WriteCurrentVersionLdml("xh", "", "", "", file);
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var ws = new WritingSystemDefinition();
adaptor.Read(file.Path, ws);
adaptor.Write(file.Path, ws, new MemoryStream(File.ReadAllBytes(file.Path), true));
AssertThatLdmlMatches("xh", "", "", "", file);
var versionReader = new WritingSystemLdmlVersionGetter();
Assert.That(LdmlDataMapper.CurrentLdmlVersion, Is.EqualTo(versionReader.GetFileVersion(file.Path)));
}
}
public void Roundtrip_LdmlFont()
{
using (var environment = new TestEnvironment())
{
var fd = new FontDefinition("Padauk")
{
RelativeSize = 2.1f,
MinVersion = "3.1.4",
Features = "order=3 children=2 color=red createDate=1996",
Language = "en",
Engines = FontEngines.Graphite | FontEngines.OpenType,
OpenTypeLanguage = "abcd",
Roles = FontRoles.Default | FontRoles.Emphasis,
Subset = "unknown"
};
fd.Urls.Add("http://wirl.scripts.sil.org/padauk");
fd.Urls.Add("http://scripts.sil.org/cms/scripts/page.php?item_id=padauk");
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.Fonts.Add(fd);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/special/sil:external-resources/sil:font[@name='Padauk' and @types='default emphasis' and @size='2.1' and @minversion='3.1.4' and @features='order=3 children=2 color=red createDate=1996' and @lang='en' and @otlang='abcd' and @subset='unknown']/sil:url[text()='http://wirl.scripts.sil.org/padauk']", environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/special/sil:external-resources/sil:font[@name='Padauk' and @types='default emphasis' and @size='2.1' and @minversion='3.1.4' and @features='order=3 children=2 color=red createDate=1996' and @lang='en' and @otlang='abcd' and @subset='unknown']/sil:url[text()='http://scripts.sil.org/cms/scripts/page.php?item_id=padauk']", environment.NamespaceManager);
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.Fonts.First().ValueEquals(fd));
}
}
public void RoundtripKnownKeyboards()
{
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
//Keyboard.Controller = new MyKeyboardController();
var wsWithKnownKeyboards = new WritingSystemDefinition();
// ID name layout local available
var keyboard1 = new DefaultKeyboardDefinition("en-US_MyFavoriteKeyboard", "MyFavoriteKeyboard", "MyFavoriteKeyboard", "en-US", true);
keyboard1.Format = KeyboardFormat.Msklc;
wsWithKnownKeyboards.KnownKeyboards.Add(keyboard1);
var keyboard2 = new DefaultKeyboardDefinition("en-GB_SusannasFavoriteKeyboard", "SusannasFavoriteKeyboard", "SusannasFavoriteKeyboard", "en-GB", true);
keyboard2.Format = KeyboardFormat.Msklc;
wsWithKnownKeyboards.KnownKeyboards.Add(keyboard2);
var wsFromLdml = new WritingSystemDefinition();
using (var tempFile = new TempFile())
{
ldmlAdaptor.Write(tempFile.Path, wsWithKnownKeyboards, null);
ldmlAdaptor.Read(tempFile.Path, wsFromLdml);
}
var knownKeyboards = wsFromLdml.KnownKeyboards.ToList();
Assert.That(knownKeyboards, Has.Count.EqualTo(2), "restored WS should have known keyboards");
var keyboard1FromLdml = knownKeyboards[0];
Assert.That(keyboard1FromLdml.Layout, Is.EqualTo("MyFavoriteKeyboard"));
Assert.That(keyboard1FromLdml.Locale, Is.EqualTo("en-US"));
var keyboard2FromLdml = knownKeyboards[1];
Assert.That(keyboard2FromLdml.Layout, Is.EqualTo("SusannasFavoriteKeyboard"));
Assert.That(keyboard2FromLdml.Locale, Is.EqualTo("en-GB"));
}
public void Roundtrip_LdmlSpellChecker()
{
using (var environment = new TestEnvironment())
{
var scd = new SpellCheckDictionaryDefinition(SpellCheckDictionaryFormat.Hunspell);
scd.Urls.Add("http://wirl.scripts.sil.org/hunspell");
scd.Urls.Add("http://scripts.sil.org/cms/scripts/page.php?item_id=hunspell");
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.SpellCheckDictionaries.Add(scd);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/special/sil:external-resources/sil:spellcheck[@type='hunspell']/sil:url[text()='http://wirl.scripts.sil.org/hunspell']", environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/special/sil:external-resources/sil:spellcheck[@type='hunspell']/sil:url[text()='http://scripts.sil.org/cms/scripts/page.php?item_id=hunspell']", environment.NamespaceManager);
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.SpellCheckDictionaries.First().ValueEquals(scd));
}
}
public void Roundtrip_VariantName()
{
using (var environment = new TestEnvironment())
{
var wsToLdml = new WritingSystemDefinition("en", "Latn", "GB", "x-test")
{
VersionNumber = "$Revision$",
VersionDescription = "Identity version description",
WindowsLcid = "1036",
DefaultRegion = "US"
};
wsToLdml.Variants[0] = new VariantSubtag(wsToLdml.Variants[0], "test0");
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/identity/language[@type='en']");
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasNoMatchForXpath("/ldml/identity/script");
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/identity/territory[@type='GB']");
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/identity/variant[@type='x-test']");
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/identity/version[@number='$Revision$' and text()='Identity version description']");
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/identity/special/sil:identity[@windowsLCID='1036' and @defaultRegion='US' and @variantName='test0']", environment.NamespaceManager);
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.VersionNumber, Is.EqualTo("$Revision$"));
Assert.That(wsFromLdml.VersionDescription, Is.EqualTo("Identity version description"));
Assert.That(wsFromLdml.LanguageTag, Is.EqualTo("en-GB-x-test"));
Assert.That(wsFromLdml.WindowsLcid, Is.EqualTo("1036"));
Assert.That(wsFromLdml.DefaultRegion, Is.EqualTo("US"));
int index = IetfLanguageTag.GetIndexOfFirstNonCommonPrivateUseVariant(wsFromLdml.Variants);
Assert.That(index, Is.EqualTo(0));
Assert.That(wsFromLdml.Variants[index].Name, Is.EqualTo("test0"));
}
}
public void Write_UnknownKeyboard_NotWrittenToLdml()
{
using (var environment = new TestEnvironment())
{
var urls = new List<string>
{
"http://wirl.scripts.sil.org/keyman",
"http://scripts.sil.org/cms/scripts/page.php?item_id=keyman9"
};
IKeyboardDefinition kbd1 = Keyboard.Controller.CreateKeyboard("Compiled Keyman9", KeyboardFormat.CompiledKeyman, urls);
IKeyboardDefinition kbd2 = Keyboard.Controller.CreateKeyboard("Unknown System Keyboard", KeyboardFormat.Unknown, urls);
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.KnownKeyboards.Add(kbd1);
wsToLdml.KnownKeyboards.Add(kbd2);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath(
"/ldml/special/sil:external-resources/sil:kbd[@id='Compiled Keyman9' and @type='kmx']/sil:url[text()='http://wirl.scripts.sil.org/keyman']",
environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath(
"/ldml/special/sil:external-resources/sil:kbd[@id='Compiled Keyman9' and @type='kmx']/sil:url[text()='http://scripts.sil.org/cms/scripts/page.php?item_id=keyman9']",
environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasNoMatchForXpath(
"/ldml/special/sil:external-resources/sil:kbd[@id='Unknown System Keyboard']",
environment.NamespaceManager);
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.KnownKeyboards.First(), Is.EqualTo(kbd1));
Assert.That(wsFromLdml.KnownKeyboards.Count, Is.EqualTo(1));
}
}
public void Roundtrip_LdmlLayout()
{
using (var environment = new TestEnvironment())
{
// Write/Read RightToLeftScript is false
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "")
{
RightToLeftScript = false
};
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/layout/orientation/characterOrder[text()='left-to-right']");
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.RightToLeftScript, Is.False);
// Write/Read RightToLeftScript is true
wsToLdml.RightToLeftScript = true;
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasAtLeastOneMatchForXpath("/ldml/layout/orientation/characterOrder[text()='right-to-left']");
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.RightToLeftScript, Is.True);
}
}
public void Write_KeyboardInfoIsOnlyWrittenOnce()
{
using (var environment = new TestEnvironment())
{
var ws = new WritingSystemDefinition("en-Zxxx-x-audio");
var keyboard1 = new DefaultKeyboardDefinition("en-US_MyFavoriteKeyboard", "MyFavoriteKeyboard", "MyFavoriteKeyboard", "en-US", true);
keyboard1.Format = KeyboardFormat.Msklc;
ws.KnownKeyboards.Add(keyboard1);
var keyboard2 = new DefaultKeyboardDefinition("en-GB_SusannasFavoriteKeyboard", "SusannasFavoriteKeyboard", "SusannasFavoriteKeyboard", "en-GB", true);
keyboard2.Format = KeyboardFormat.Msklc;
ws.KnownKeyboards.Add(keyboard2);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), ws, null);
//read the file and write it out unchanged
var ws2 = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), ws2);
ldmlAdaptor.Write(environment.FilePath("test.ldml"), ws2, new MemoryStream(File.ReadAllBytes(environment.FilePath("test.ldml"))));
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasSpecifiedNumberOfMatchesForXpath("/ldml/special/sil:external-resources/sil:kbd[@id='en-US_MyFavoriteKeyboard' and @type='msklc']", 1, environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml")).HasSpecifiedNumberOfMatchesForXpath("/ldml/special/sil:external-resources/sil:kbd[@id='en-GB_SusannasFavoriteKeyboard' and @type='msklc']", 1, environment.NamespaceManager);
}
}
public void Roundtrip_LdmlCharacters()
{
using (var environment = new TestEnvironment())
{
var index = new CharacterSetDefinition("index");
for (int i = 'A'; i <= (int) 'Z'; i++)
index.Characters.Add(((char) i).ToString(CultureInfo.InvariantCulture));
index.Characters.Add("AZ");
var main = new CharacterSetDefinition("main");
for (int i = 'a'; i <= (int) 'z'; i++)
main.Characters.Add(((char) i).ToString(CultureInfo.InvariantCulture));
main.Characters.Add("az");
var footnotes = new CharacterSetDefinition("footnotes") {Characters = {"¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹", "¹⁰"}};
var numeric = new CharacterSetDefinition("numeric") {Characters = {"๐", "๑", "๒", "๓", "๔", "๕", "๖", "๗", "๘", "๙"}};
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.CharacterSets.Add(index);
wsToLdml.CharacterSets.Add(main);
wsToLdml.CharacterSets.Add(footnotes);
wsToLdml.CharacterSets.Add(numeric);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/characters/exemplarCharacters[@type='index' and text()='[A-Z{AZ}]']", environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/characters/exemplarCharacters[text()='[a-z{az}]']", environment.NamespaceManager);
// Character set in XPath is escaped differently from the actual file
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/characters/special/sil:exemplarCharacters[@type='footnotes' and text()='[¹ ² ³ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹ {¹⁰}]']", environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/numbers/defaultNumberingSystem[text()='standard']", environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/numbers/numberingSystem[@id='standard' and @type='numeric' and @digits='๐๑๒๓๔๕๖๗๘๙']", environment.NamespaceManager);
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.CharacterSets["index"].ValueEquals(index), Is.True);
Assert.That(wsFromLdml.CharacterSets["main"].ValueEquals(main), Is.True);
Assert.That(wsFromLdml.CharacterSets["footnotes"].ValueEquals(footnotes), Is.True);
Assert.That(wsFromLdml.CharacterSets["numeric"].ValueEquals(numeric), Is.True);
}
}
public void Write_NoLdmlCollations_CollationsNotWrittenToLdml()
{
using (var environment = new TestEnvironment())
{
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.DefaultCollation = new SystemCollationDefinition {LanguageTag = "en-US"};
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
ldmlAdaptor.Write(environment.FilePath("test.ldml"), wsToLdml, null);
AssertThatXmlIn.File(environment.FilePath("test.ldml"))
.HasNoMatchForXpath(
"/ldml/collations",
environment.NamespaceManager);
}
}
public void Roundtrip_LdmlAlternateCharacters_Ignored()
{
// Test when reading LDML that elements with alt attribute are ignored.
// Because we don't write elements with alt attribute, this test
// starts by writing a set content
using (var environment = new TestEnvironment())
{
string content =
@"<?xml version='1.0' encoding='utf-8'?>
<ldml>
<identity>
<version number='' />
<language type='en' />
<script type='Latn' />
</identity>
<characters>
<exemplarCharacters alt='capital'>[A-Z{AZ}]</exemplarCharacters>
<exemplarCharacters>[a-z{az}]</exemplarCharacters>
</characters>
</ldml>".Replace("\'", "\"");
var main = new CharacterSetDefinition("main");
for (int i = 'a'; i <= (int)'z'; i++)
main.Characters.Add(((char)i).ToString(CultureInfo.InvariantCulture));
main.Characters.Add("az");
File.WriteAllText(environment.FilePath("test.ldml"), content);
var ldmlAdaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var wsFromLdml = new WritingSystemDefinition();
ldmlAdaptor.Read(environment.FilePath("test.ldml"), wsFromLdml);
Assert.That(wsFromLdml.CharacterSets.Count, Is.EqualTo(1));
Assert.That(wsFromLdml.CharacterSets["main"].ValueEquals(main));
var wsToLdml = new WritingSystemDefinition("en", "Latn", "", "");
wsToLdml.CharacterSets.Add(main);
ldmlAdaptor.Write(environment.FilePath("test2.ldml"), wsToLdml, new MemoryStream(File.ReadAllBytes(environment.FilePath("test.ldml"))));
AssertThatXmlIn.File(environment.FilePath("test2.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/characters/exemplarCharacters[text()='[a-z{az}]']", environment.NamespaceManager);
AssertThatXmlIn.File(environment.FilePath("test2.ldml"))
.HasAtLeastOneMatchForXpath("/ldml/characters/exemplarCharacters[@alt='capital' and text()='[A-Z{AZ}]']", environment.NamespaceManager);
}
}
public void Write_WritingSystemWasloadedFromLdmlThatContainedLayoutInfo_LayoutInfoIsOnlyWrittenOnce()
{
using (var file = new TempFile())
{
//create an ldml file to read that contains layout info
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var ws = new WritingSystemDefinition("en-Zxxx-x-audio") {RightToLeftScript = true};
adaptor.Write(file.Path, ws, null);
//read the file and write it out unchanged
var ws2 = new WritingSystemDefinition();
adaptor.Read(file.Path, ws2);
adaptor.Write(file.Path, ws2, new MemoryStream(File.ReadAllBytes(file.Path)));
AssertThatXmlIn.File(file.Path).HasNoMatchForXpath("/ldml/layout[2]");
}
}
public void WriteToXmlWriter_NullWritingSystem_Throws()
{
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
Assert.Throws<ArgumentNullException>(
() => adaptor.Write(XmlWriter.Create(new MemoryStream()), null, null)
);
}
public void Read_V1Ldml_ThrowFriendlyException()
{
using (var file = new TempFile())
{
// Note: Version 1 Ldml is written with Version 2
WriteVersion1Ldml("en", "", "", "", file);
var ws = new WritingSystemDefinition();
var dataMapper = new LdmlDataMapper(new TestWritingSystemFactory());
Assert.That(() => dataMapper.Read(file.Path, ws),
Throws.Exception.TypeOf<ApplicationException>()
.With.Property("Message")
.EqualTo(String.Format("The LDML tag 'en' is version 2. Version {0} was expected.",
LdmlDataMapper.CurrentLdmlVersion)));
}
}
public void Write_InvalidLanguageTag_Throws()
{
var ws = new WritingSystemDefinition {Language = "InvalidLanguage"};
var adaptor = new LdmlDataMapper(new TestWritingSystemFactory());
var sw = new StringWriter();
var writer = XmlWriter.Create(sw, CanonicalXmlSettings.CreateXmlWriterSettings());
Assert.Throws<ArgumentException>(() => adaptor.Write(writer, ws, null));
}
