Esempi in C# (CSharp) per MemorySettingsStore

Esempio n. 1

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: venukommu/libpalaso

        public void Write_EmptyXml_XmlUpdated()
        {
            var settingsStore             = new MemorySettingsStore();
            var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);

            var ws1 = new WritingSystemDefinition("qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2");

            ws1.Language    = new LanguageSubtag(ws1.Language, "Kalaba");
            ws1.Script      = new ScriptSubtag(ws1.Script, "Fake");
            ws1.Region      = new RegionSubtag(ws1.Region, "Zolrog");
            ws1.Variants[0] = new VariantSubtag(ws1.Variants[0], "Custom 1");
            ws1.Variants[1] = new VariantSubtag(ws1.Variants[1], "Custom 2");
            projectSettingsDataMapper.Write(ws1);

            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>"));
        }

Esempio n. 2

File: ProjectLexiconSettingsDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Write_ValidXml_XmlUpdated()
		{
			const string projectSettingsXml =
@"<ProjectLexiconSettings>
  <WritingSystems addToSldr=""false"">
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

			var settingsStore = new MemorySettingsStore {SettingsElement = XElement.Parse(projectSettingsXml)};
			var projectSettingsDataMapper = new ProjectLexiconSettingsDataMapper(settingsStore);
			var settings = new ProjectLexiconSettings {AddWritingSystemsToSldr = true};
			projectSettingsDataMapper.Write(settings);

			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<ProjectLexiconSettings>
  <WritingSystems addToSldr=""true"">
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 3

File: ProjectLexiconSettingsDataMapperTests.cs Progetto: sujeffreyl/libpalaso

        public void ProjectSharing_Is_Unchecked()
        {
            const string projectSettingsXml =
                @"<ProjectLexiconSettings projectSharing=""true"">
  <WritingSystems addToSldr=""false"">
	<WritingSystem id=""fr-FR"">
		<SpellCheckingId>fr_FR</SpellCheckingId>
		<LegacyMapping>converter</LegacyMapping>
		<Keyboard>Old Keyboard</Keyboard>
	</WritingSystem>
</WritingSystems>
</ProjectLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(projectSettingsXml)
            };
            var projectSettingsDataMapper = new ProjectLexiconSettingsDataMapper(settingsStore);
            var settings = new ProjectLexiconSettings {
                AddWritingSystemsToSldr = true, ProjectSharing = false
            };

            projectSettingsDataMapper.Write(settings);

            Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
                                                                      @"<ProjectLexiconSettings projectSharing=""false"">
  <WritingSystems addToSldr=""true"">
	<WritingSystem id=""fr-FR"">
		<SpellCheckingId>fr_FR</SpellCheckingId>
		<LegacyMapping>converter</LegacyMapping>
		<Keyboard>Old Keyboard</Keyboard>
	</WritingSystem>
</WritingSystems>
</ProjectLexiconSettings>")).Using((IEqualityComparer <XNode>) new XNodeEqualityComparer()));
        }

Esempio n. 4

        public void Remove_ExistingWritingSystem_UpdatesXml()
        {
            const string userSettingsXml =
                @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
    <WritingSystem id=""fr-FR"">
      <DefaultFontSize>12</DefaultFontSize>
      <IsGraphiteEnabled>false</IsGraphiteEnabled>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(userSettingsXml)
            };
            var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);

            userSettingsDataMapper.Remove("fr-FR");
            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>"));

            userSettingsDataMapper.Remove("en-US");
            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo("<UserLexiconSettings />"));
        }

Esempio n. 5

File: UserLexiconSettingsWritingSystemDataMapperTests.cs Progetto: vkarthim/libpalaso

        public void Remove_NonexistentWritingSystem_DoesNotUpdateXml()
        {
            const string userSettingsXml =
                @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(userSettingsXml)
            };
            var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);

            userSettingsDataMapper.Remove("fr-FR");
            Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
                                                                      @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>")).Using((IEqualityComparer <XNode>) new XNodeEqualityComparer()));
        }

Esempio n. 6

File: ProjectLexiconSettingsDataMapperTests.cs Progetto: sujeffreyl/libpalaso

        public void Write_ValidXml_XmlUpdated()
        {
            const string projectSettingsXml =
                @"<ProjectLexiconSettings projectSharing=""false"">
  <WritingSystems addToSldr=""false"">
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(projectSettingsXml)
            };
            var projectSettingsDataMapper = new ProjectLexiconSettingsDataMapper(settingsStore);
            var settings = new ProjectLexiconSettings {
                AddWritingSystemsToSldr = true, ProjectSharing = true
            };

            projectSettingsDataMapper.Write(settings);

            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<ProjectLexiconSettings projectSharing=""true"">
  <WritingSystems addToSldr=""true"">
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>"));
        }

Esempio n. 7

File: ProjectLexiconSettingsDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Write_EmptyXml_XmlUpdated()
		{
			var settingsStore = new MemorySettingsStore();
			var projectSettingsDataMapper = new ProjectLexiconSettingsDataMapper(settingsStore);

			var settings = new ProjectLexiconSettings {AddWritingSystemsToSldr = true};
			projectSettingsDataMapper.Write(settings);

			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<ProjectLexiconSettings>
  <WritingSystems addToSldr=""true"" />
</ProjectLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 8

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: venukommu/libpalaso

        public void Remove_ExistingWritingSystem_UpdatesXml()
        {
            const string projectSettingsXml =
                @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(projectSettingsXml)
            };
            var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);

            projectSettingsDataMapper.Remove("fr-FR");
            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>"));

            projectSettingsDataMapper.Remove("qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2");
            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo("<ProjectLexiconSettings />"));
        }

Esempio n. 9

File: ProjectLexiconSettingsDataMapperTests.cs Progetto: sujeffreyl/libpalaso

        public void Write_EmptyXml_XmlUpdated()
        {
            var settingsStore             = new MemorySettingsStore();
            var projectSettingsDataMapper = new ProjectLexiconSettingsDataMapper(settingsStore);

            var settings = new ProjectLexiconSettings {
                AddWritingSystemsToSldr = true, ProjectSharing = true
            };

            projectSettingsDataMapper.Write(settings);

            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<ProjectLexiconSettings projectSharing=""true"">
  <WritingSystems addToSldr=""true"" />
</ProjectLexiconSettings>"));
        }

Esempio n. 10

File: ProjectLexiconSettingsDataMapperTests.cs Progetto: vkarthim/libpalaso

        public void Write_EmptyXml_XmlUpdated()
        {
            var settingsStore             = new MemorySettingsStore();
            var projectSettingsDataMapper = new ProjectLexiconSettingsDataMapper(settingsStore);

            var settings = new ProjectLexiconSettings {
                AddWritingSystemsToSldr = true
            };

            projectSettingsDataMapper.Write(settings);

            Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
                                                                      @"<ProjectLexiconSettings>
  <WritingSystems addToSldr=""true"" />
</ProjectLexiconSettings>")).Using((IEqualityComparer <XNode>) new XNodeEqualityComparer()));
        }

Esempio n. 11

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: venukommu/libpalaso

        public void Write_ValidXml_XmlUpdated()
        {
            const string projectSettingsXml =
                @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2-var3"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(projectSettingsXml)
            };
            var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);
            var ws1 = new WritingSystemDefinition("qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2-var3");

            ws1.Abbreviation    = "ka";
            ws1.SpellCheckingId = "en_US";
            ws1.LegacyMapping   = "converter";
            ws1.Keyboard        = "Old Keyboard";
            var scd = new SystemCollationDefinition {
                LanguageTag = "snarf"
            };

            ws1.DefaultCollation = scd;
            projectSettingsDataMapper.Write(ws1);

            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2-var3"">
      <Abbreviation>ka</Abbreviation>
      <SpellCheckingId>en_US</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
      <SystemCollation>snarf</SystemCollation>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>"));
        }

Esempio n. 12

File: UserLexiconSettingsWritingSystemDataMapperTests.cs Progetto: vkarthim/libpalaso

        public void Write_ValidXml_XmlUpdated()
        {
            const string userSettingsXml =
                @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <KnownKeyboards>
        <KnownKeyboard>en-US_English-IPA</KnownKeyboard>
      </KnownKeyboards>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(userSettingsXml)
            };
            var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);
            var ws1 = new WritingSystemDefinition("en-US");

            ws1.LocalKeyboard     = Keyboard.Controller.CreateKeyboard("en-US_English", KeyboardFormat.Unknown, Enumerable.Empty <string>());
            ws1.DefaultFont       = null;
            ws1.DefaultFontSize   = 12;
            ws1.IsGraphiteEnabled = false;
            userSettingsDataMapper.Write(ws1);

            Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
                                                                      @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English</LocalKeyboard>
      <KnownKeyboards>
        <KnownKeyboard>en-US_English</KnownKeyboard>
      </KnownKeyboards>
      <DefaultFontSize>12</DefaultFontSize>
      <IsGraphiteEnabled>false</IsGraphiteEnabled>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>")).Using((IEqualityComparer <XNode>) new XNodeEqualityComparer()));
        }

Esempio n. 13

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: venukommu/libpalaso

        public void Remove_NonexistentWritingSystem_DoesNotUpdateFile()
        {
            const string projectSettingsXml =
                @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(projectSettingsXml)
            };
            var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);

            projectSettingsDataMapper.Remove("fr-FR");
            Assert.That(settingsStore.SettingsElement, Is.XmlEqualTo(
                            @"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>"));
        }

Esempio n. 14

File: UserLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Write_EmptyXml_XmlUpdated()
		{
			var settingsStore = new MemorySettingsStore();
			var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);

			var ws1 = new WritingSystemDefinition("en-US");
			ws1.LocalKeyboard = Keyboard.Controller.CreateKeyboard("en-US_English-IPA", KeyboardFormat.Unknown, Enumerable.Empty<string>());
			ws1.DefaultFont = new FontDefinition("Times New Roman");
			userSettingsDataMapper.Write(ws1);

			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <KnownKeyboards>
        <KnownKeyboard>en-US_English-IPA</KnownKeyboard>
      </KnownKeyboards>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 15

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: venukommu/libpalaso

        public void Remove_FinalWritingSystem_PreservesSettings()
        {
            const string projectSettingsXml =
                @"<ProjectLexiconSettings>
  <WritingSystems addToSldr=""true"">
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

            var settingsStore = new MemorySettingsStore {
                SettingsElement = XElement.Parse(projectSettingsXml)
            };
            var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);

            projectSettingsDataMapper.Remove("fr-FR");
            Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
                                                                      @"<ProjectLexiconSettings>
  <WritingSystems addToSldr=""true""/>
</ProjectLexiconSettings>")).Using((IEqualityComparer <XNode>) new XNodeEqualityComparer()));
        }

Esempio n. 16

File: UserLexiconSettingsWritingSystemDataMapperTests.cs Progetto: vkarthim/libpalaso

        public void Write_EmptyXml_XmlUpdated()
        {
            var settingsStore          = new MemorySettingsStore();
            var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);

            var ws1 = new WritingSystemDefinition("en-US");

            ws1.LocalKeyboard = Keyboard.Controller.CreateKeyboard("en-US_English-IPA", KeyboardFormat.Unknown, Enumerable.Empty <string>());
            ws1.DefaultFont   = new FontDefinition("Times New Roman");
            userSettingsDataMapper.Write(ws1);

            Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
                                                                      @"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <KnownKeyboards>
        <KnownKeyboard>en-US_English-IPA</KnownKeyboard>
      </KnownKeyboards>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>")).Using((IEqualityComparer <XNode>) new XNodeEqualityComparer()));
        }

Esempio n. 17

File: UserLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Write_ValidXml_XmlUpdated()
		{
			const string userSettingsXml =
@"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <KnownKeyboards>
        <KnownKeyboard>en-US_English-IPA</KnownKeyboard>
      </KnownKeyboards>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>";

			var settingsStore = new MemorySettingsStore {SettingsElement = XElement.Parse(userSettingsXml)};
			var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);
			var ws1 = new WritingSystemDefinition("en-US");
			ws1.LocalKeyboard = Keyboard.Controller.CreateKeyboard("en-US_English", KeyboardFormat.Unknown, Enumerable.Empty<string>());
			ws1.DefaultFont = null;
			ws1.DefaultFontSize = 12;
			ws1.IsGraphiteEnabled = false;
			userSettingsDataMapper.Write(ws1);

			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English</LocalKeyboard>
      <KnownKeyboards>
        <KnownKeyboard>en-US_English</KnownKeyboard>
      </KnownKeyboards>
      <DefaultFontSize>12</DefaultFontSize>
      <IsGraphiteEnabled>false</IsGraphiteEnabled>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 18

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Write_EmptyXml_XmlUpdated()
		{
			var settingsStore = new MemorySettingsStore();
			var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);

			var ws1 = new WritingSystemDefinition("qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2");
			ws1.Language = new LanguageSubtag(ws1.Language, "Kalaba");
			ws1.Script = new ScriptSubtag(ws1.Script, "Fake");
			ws1.Region = new RegionSubtag(ws1.Region, "Zolrog");
			ws1.Variants[0] = new VariantSubtag(ws1.Variants[0], "Custom 1");
			ws1.Variants[1] = new VariantSubtag(ws1.Variants[1], "Custom 2");
			projectSettingsDataMapper.Write(ws1);

			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 19

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Remove_NonexistentWritingSystem_DoesNotUpdateFile()
		{
			const string projectSettingsXml =
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

			var settingsStore = new MemorySettingsStore {SettingsElement = XElement.Parse(projectSettingsXml)};
			var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);
			projectSettingsDataMapper.Remove("fr-FR");
			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 20

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Remove_ExistingWritingSystem_UpdatesXml()
		{
			const string projectSettingsXml =
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

			var settingsStore = new MemorySettingsStore {SettingsElement = XElement.Parse(projectSettingsXml)};
			var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);
			projectSettingsDataMapper.Remove("fr-FR");
			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
      <VariantNames>
        <VariantName>Custom 1</VariantName>
        <VariantName>Custom 2</VariantName>
      </VariantNames>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));

			projectSettingsDataMapper.Remove("qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2");
			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse("<ProjectLexiconSettings />")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 21

File: ProjectLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Write_ValidXml_XmlUpdated()
		{
			const string projectSettingsXml =
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2-var3"">
      <Abbreviation>kal</Abbreviation>
      <LanguageName>Kalaba</LanguageName>
      <ScriptName>Fake</ScriptName>
      <RegionName>Zolrog</RegionName>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

			var settingsStore = new MemorySettingsStore {SettingsElement = XElement.Parse(projectSettingsXml)};
			var projectSettingsDataMapper = new ProjectLexiconSettingsWritingSystemDataMapper(settingsStore);
			var ws1 = new WritingSystemDefinition("qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2-var3");
			ws1.Abbreviation = "ka";
			ws1.SpellCheckingId = "en_US";
			ws1.LegacyMapping = "converter";
			ws1.Keyboard = "Old Keyboard";
			var scd = new SystemCollationDefinition {LanguageTag = "snarf"};
			ws1.DefaultCollation = scd;
			projectSettingsDataMapper.Write(ws1);

			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<ProjectLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""qaa-Qaaa-QM-x-kal-Fake-ZG-var1-var2-var3"">
      <Abbreviation>ka</Abbreviation>
      <SpellCheckingId>en_US</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
      <SystemCollation>snarf</SystemCollation>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}

Esempio n. 22

File: UserLexiconSettingsWritingSystemDataMapperTests.cs Progetto: jwickberg/libpalaso

		public void Remove_NonexistentWritingSystem_DoesNotUpdateXml()
		{
			const string userSettingsXml =
@"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>";

			var settingsStore = new MemorySettingsStore {SettingsElement = XElement.Parse(userSettingsXml)};
			var userSettingsDataMapper = new UserLexiconSettingsWritingSystemDataMapper(settingsStore);
			userSettingsDataMapper.Remove("fr-FR");
			Assert.That(settingsStore.SettingsElement, Is.EqualTo(XElement.Parse(
@"<UserLexiconSettings>
  <WritingSystems>
    <WritingSystem id=""en-US"">
      <LocalKeyboard>en-US_English-IPA</LocalKeyboard>
      <DefaultFontName>Times New Roman</DefaultFontName>
    </WritingSystem>
  </WritingSystems>
</UserLexiconSettings>")).Using((IEqualityComparer<XNode>) new XNodeEqualityComparer()));
		}