public void IpaStatus_SetToIpaWasAlreadyIpaWithOtherVariants_NoChange()
		{
			var ws = new WritingSystemDefinition();
			ws.Variants.AddRange(new VariantSubtag[] {"1901", "biske", "fonipa"});
			ws.IpaStatus = IpaStatusChoices.Ipa;
			Assert.That(ws.Variants, Is.EqualTo(new VariantSubtag[] {"1901", "biske", "fonipa"}));
		}

		public IEnumerable<IWritingSystemDefinitionSuggestion> GetSuggestions(WritingSystemDefinition primary, IEnumerable<WritingSystemDefinition> existingWritingSystemsForLanguage)
		{
			if (primary.Language == null && primary.Variants.Any(v => !v.IsPrivateUse))
				yield break;

			if (SuppressSuggestionsForMajorWorldLanguages
			   && new[]{"en", "th", "es", "fr", "de", "hi", "id", "vi","my","pt", "fi", "ar", "it","sv", "ja", "ko", "ch", "nl", "ru"}.Contains((string) primary.Language))
				yield break;

			WritingSystemDefinition[] existingWSs = existingWritingSystemsForLanguage.ToArray();

			if (SuggestIpa && IpaSuggestion.ShouldSuggest(existingWSs))
			{
				yield return new IpaSuggestion(_writingSystemFactory, primary);
			}

			if (SuggestVoice && VoiceSuggestion.ShouldSuggest(existingWSs))
			{
				yield return new VoiceSuggestion(_writingSystemFactory, primary);
			}

			if (SuggestDialects)
			{
				yield return new DialectSuggestion(_writingSystemFactory, primary);
			}

			if (SuggestOther)
			{
				yield return new OtherSuggestion(_writingSystemFactory, primary, existingWSs);
			}
		}

		public void IpaStatus_SetToIpaWasAlreadyIpaWithOtherVariants_NoChange()
		{
			var ws = new WritingSystemDefinition();
			ws.Variant = "1901-biske-fonipa";
			ws.IpaStatus = IpaStatusChoices.Ipa;
			Assert.AreEqual("1901-biske-fonipa", ws.Variant);
		}

		public DeleteInputSystemDialog(WritingSystemDefinition wsToDelete,
									   IEnumerable<WritingSystemDefinition> possibleWritingSystemsToConflateWith, bool showHelpButton)
		{
			InitializeComponent();
			if (!showHelpButton)
			{
				_helpButton.Hide();
			}
			_deleteRadioButton.Text = String.Format(_deleteRadioButton.Text, DisplayName(wsToDelete));
			_mergeRadioButton.Text = String.Format(_mergeRadioButton.Text, DisplayName(wsToDelete));
			_wsSelectionComboBox.Items.AddRange(
				possibleWritingSystemsToConflateWith.Where(ws => ws != wsToDelete).Select(ws=>new WritingSystemDisplayAdaptor(ws)).ToArray());
			Choice = Choices.Delete;
			if (_wsSelectionComboBox.Items.Count > 0)
			{
				_wsSelectionComboBox.SelectedIndex = 0;
			}
			_wsSelectionComboBox.DropDownStyle = ComboBoxStyle.DropDownList;
			_okButton.Click += OnOkClicked;
			_cancelButton.Click += OnCancelClicked;
			_deleteRadioButton.CheckedChanged += OnDeleteRadioButtonCheckedChanged;
			_mergeRadioButton.CheckedChanged += OnMergeRadioButtonCheckedChanged;
			_helpButton.Click += OnCustomHelpButtonClicked;
			_deleteRadioButton.Checked = true;
		}

		public void IpaStatus_SetToIpaWasAlreadyIpaAndOnyVariant_NoChange()
		{
			var ws = new WritingSystemDefinition();
			ws.IpaStatus = IpaStatusChoices.Ipa;
			ws.Variant = "fonipa";
			Assert.AreEqual("fonipa", ws.Variant);
		}

		public void Setup()
		{
			_temporaryFolder = new TemporaryFolder();
			string filePath = _temporaryFolder.GetTemporaryFile();
			_repository = new LiftLexEntryRepository(filePath);
			_headwordWritingSystem = new WritingSystemDefinition("th");
		}

			public TestEnvironment()
			{
				_temporaryFolder = new TemporaryFolder("LiftLexEntryRepositoryTests");
				string filePath = _temporaryFolder.GetTemporaryFile();
				_repository = new LiftLexEntryRepository(filePath);
				_headwordWritingSystem = new WritingSystemDefinition("th") {DefaultCollation = new IcuRulesCollationDefinition("standard")};
			}

		public void IpaStatus_SetToIpaWhenVariantHasContents_FonIpaAtEnd()
		{
			var ws = new WritingSystemDefinition();
			ws.Variants.AddRange(new VariantSubtag[] {"1901", "biske"});
			ws.IpaStatus = IpaStatusChoices.Ipa;
			Assert.That(ws.Variants, Is.EqualTo(new VariantSubtag[] {"1901", "biske", "fonipa"}));
		}

		public void IpaStatus_SetToNotIpaWhenWasOnlyVariant_FonIpaRemoved()
		{
			var ws = new WritingSystemDefinition();
			ws.Variants.Add("fonipa");
			ws.IpaStatus = IpaStatusChoices.NotIpa;
			Assert.That(ws.Variants, Is.Empty);
		}

		public void Read_ValidXml_SetsAllProperties()
		{
			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>
      <SystemCollation>snarf</SystemCollation>
    </WritingSystem>
    <WritingSystem id=""fr-FR"">
      <SpellCheckingId>fr_FR</SpellCheckingId>
      <LegacyMapping>converter</LegacyMapping>
      <Keyboard>Old Keyboard</Keyboard>
    </WritingSystem>
  </WritingSystems>
</ProjectLexiconSettings>";

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

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

			Assert.That(ws1.Abbreviation, Is.EqualTo("kal"));
			Assert.That(ws1.Language.Name, Is.EqualTo("Kalaba"));
			Assert.That(ws1.Script.Name, Is.EqualTo("Fake"));
			Assert.That(ws1.Region.Name, Is.EqualTo("Zolrog"));
			Assert.That(ws1.SpellCheckingId, Is.EqualTo(string.Empty));
			Assert.That(ws1.LegacyMapping, Is.EqualTo(string.Empty));
			Assert.That(ws1.Keyboard, Is.EqualTo(string.Empty));
			var scd = new SystemCollationDefinition {LanguageTag = "snarf"};
			Assert.That(ws1.DefaultCollation.ValueEquals(scd), Is.True);

			var ws2 = new WritingSystemDefinition("fr-FR");
			projectSettingsDataMapper.Read(ws2);

			Assert.That(ws2.Abbreviation, Is.EqualTo("fr"));
			Assert.That(ws2.Language.Name, Is.EqualTo("French"));
			Assert.That(ws2.Script.Name, Is.EqualTo("Latin"));
			Assert.That(ws2.Region.Name, Is.EqualTo("France"));
			Assert.That(ws2.Variants, Is.Empty);
			Assert.That(ws2.SpellCheckingId, Is.EqualTo("fr_FR"));
			Assert.That(ws2.LegacyMapping, Is.EqualTo("converter"));
			Assert.That(ws2.Keyboard, Is.EqualTo("Old Keyboard"));

			var ws3 = new WritingSystemDefinition("es");
			projectSettingsDataMapper.Read(ws3);

			Assert.That(ws3.Abbreviation, Is.EqualTo("es"));
			Assert.That(ws3.Language.Name, Is.EqualTo("Spanish"));
			Assert.That(ws3.Script.Name, Is.EqualTo("Latin"));
			Assert.That(ws3.Region, Is.Null);
			Assert.That(ws3.Variants, Is.Empty);
			Assert.That(ws3.SpellCheckingId, Is.EqualTo(string.Empty));
			Assert.That(ws3.LegacyMapping, Is.EqualTo(string.Empty));
			Assert.That(ws3.Keyboard, Is.EqualTo(string.Empty));
		}

		public override bool Create(string ietfLanguageTag, out WritingSystemDefinition ws)
		{
			if (_writingSystems.TryGet(ietfLanguageTag, out ws))
				return true;

			ws = ConstructDefinition(ietfLanguageTag);
			return true;
		}

		public virtual void SetUp()
		{
			_writingSystem = new WritingSystemDefinition();
			RepositoryUnderTest = CreateNewStore();
			_writingSystemIdChangedEventArgs = null;
			_writingSystemDeletedEventArgs = null;
			_writingSystemConflatedEventArgs = null;
		}

		private static WritingSystemDefinition WritingSystemDefinitionForTest(string languageISO, Font font)
		{
			var retval = new WritingSystemDefinition();
			retval.Language = languageISO;
			retval.DefaultFontName = font.Name;
			retval.DefaultFontSize = font.Size;
			return retval;
		}

 public void AllWritingSystems_HasAllWritingSystems_ReturnsAllWritingSystems()
 {
     var ws1 = new WritingSystemDefinition("fr");
     ws1.IsVoice = true;
     RepositoryUnderTest.Set(ws1);
     RepositoryUnderTest.Set(new WritingSystemDefinition("de"));
     RepositoryUnderTest.Set(new WritingSystemDefinition("es"));
     Assert.IsTrue(RepositoryUnderTest.AllWritingSystems.Count() == 3);
 }

		public void SetTwoDefinitions_CountEquals2()
		{
			_writingSystem.Language = "one";
			RepositoryUnderTest.Set(_writingSystem);
			var ws2 = new WritingSystemDefinition();
			ws2.Language = "two";
			RepositoryUnderTest.Set(ws2);

			Assert.AreEqual(2, RepositoryUnderTest.Count);
		}

		[Test] // ok
		public void GetSuggestions_HasNormalAndIPA_DoesNotIncludeItemToCreateIPA()
		{
			var etr = new WritingSystemDefinition("etr", string.Empty, string.Empty, string.Empty, "edo", false);
			var etrIpa = new WritingSystemDefinition("etr", string.Empty, string.Empty,  "fonipa", "edo", false);
			var list = new List<WritingSystemDefinition>(new[] { etr, etrIpa });
			var suggestor = new WritingSystemSuggestor(new TestWritingSystemFactory());
			IEnumerable<IWritingSystemDefinitionSuggestion> suggestions = suggestor.GetSuggestions(etr, list);

			Assert.That(suggestions.Any(defn => defn is IpaSuggestion), Is.False);
		}

		public void Init(WritingSystemDefinition writingSystem, String name)
		{
			WritingSystem = writingSystem;
			_nameForLogging = name;
			if (_nameForLogging == null)
			{
				_nameForLogging = "??";
			}
			Name = name;
		}

		[Test] // ok
		public void GetSuggestions_HasNormalAndIPA_DoesNotIncludeItemToCreateIPA()
		{
			var etr = new WritingSystemDefinition("etr", string.Empty, string.Empty, string.Empty, "edo", false);
			var etrIpa = new WritingSystemDefinition("etr", string.Empty, string.Empty,  "fonipa", "edo", false);
			var list = new List<WritingSystemDefinition>(new[] { etr, etrIpa });
			var suggestor = new WritingSystemSuggestor();
			var suggestions = suggestor.GetSuggestions(etr, list);

			Assert.IsFalse(suggestions.Any(defn => ((WritingSystemSuggestion)defn).TemplateDefinition.Variant == "fonipa"));
		}

		public void Set_NewWritingSystem_SetsId()
		{
			using (var e = new TemporaryFolder("GlobalWritingSystemRepositoryTests"))
			{
				var repo = new GlobalWritingSystemRepository(e.Path);
				var ws = new WritingSystemDefinition("en-US");
				Assert.That(ws.Id, Is.Null);
				repo.Set(ws);
				Assert.That(ws.Id, Is.EqualTo("en-US"));
			}
		}

		public GeckoBox(WritingSystemDefinition ws, string nameForLogging)
			: this()
		{
			_nameForLogging = nameForLogging;
			if (_nameForLogging == null)
			{
				_nameForLogging = "??";
			}
			Name = _nameForLogging;
			WritingSystem = ws;
		}