feat: drop test-time dependency on registry-backed SilEncConverters40 EncConverters

- Replace direct static look‑ups of SilEncConverters40.EncConverters in unit tests
  with Moq fakes (IEncConverter/IEncConverters) and lazy‑init seams.
- Guard EncConverters creation in SCTextEnum so it only occurs when a
  LegacyMapping is actually required, eliminating eager registry access.
- Update affected Paratext import and Interlinear SFM import tests to use the
  new fakes and verify behavior without relying on global process/registry state.

This removes non‑deterministic HKLM\Software\... registry dependencies from the
test suite, making CI runs repeatable and allowing the code to be built/run in
environments where those keys are absent.

Author: johnml1135

Src/FwCoreDlgs/CnvtrPropertiesCtrl.cs

@@ -586,15 +586,10 @@ public void CnvtrPropertiesCtrl_Load(object sender, System.EventArgs e)
 		{
 			CheckDisposed();
 
-			// This is a fall-back if the creator does not have a converters object.
-			// It is generally preferable for the creator to make one and pass it in.
-			// Multiple EncConverters objects are problematical because they don't all get
-			// updated when something changes.
-			// JohnT: note that this ALWAYS happens at least once, because the Load event happens during
-			// the main dialog's InitializeComponent method, before it sets the encConverters
-			// of the control.
-			if (m_encConverters == null)
-				m_encConverters = new EncConverters();
+			// Do not instantiate EncConverters here.
+			// The creator normally supplies the instance after InitializeComponent; creating one
+			// during Load can have undesirable side-effects (registry and repository IO) and can
+			// break unit tests. Methods that truly require EncConverters should create it lazily.
 			cboConverter.Items.Clear();
 			cboConverter.Items.Add(new CnvtrTypeComboItem(AddConverterResources.kstrCc, ConverterType.ktypeCC, EncConverters.strTypeSILcc));
 			if (!m_fOnlyUnicode)
@@ -636,6 +631,12 @@ public void CnvtrPropertiesCtrl_Load(object sender, System.EventArgs e)
 			}
 		}
 
+		private void EnsureEncConverters()
+		{
+			if (m_encConverters == null)
+				m_encConverters = new EncConverters();
+		}
+
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
 		/// Handles the Click event of the btnMapFile control.
@@ -731,7 +732,9 @@ public void SelectMapping(string mapname)
 			m_selectingMapping = true;
 
 			txtName.Text = mapname;
-			IEncConverter conv = m_encConverters[mapname];
+			IEncConverter conv = null;
+			if (m_encConverters != null)
+				conv = m_encConverters[mapname];
 			ConvType convType;
 			string implType;
 			EncoderInfo undefinedEncoder = null; // in case the current selection is not fully defined
@@ -1018,6 +1021,8 @@ internal void SetStates(bool existingConvs, bool installedConverter)
 		/// ------------------------------------------------------------------------------------
 		private void btnModify_Click(object sender, EventArgs e)
 		{
+			EnsureEncConverters();
+
 			// call the v2.2 interface to "AutoConfigure" a converter
 			string strFriendlyName = ConverterName;
 			IEncConverter aEC = m_encConverters[strFriendlyName];
@@ -1125,6 +1130,8 @@ string strRhsEncodingID
 		/// ------------------------------------------------------------------------------------
 		private void AddToCollection(IEncConverter rConverter, string converterName)
 		{
+			EnsureEncConverters();
+
 			// now add it to the 'this' collection
 			// converterName.ToLower(); // this does nothing anyway, so get rid of it
 

Src/FwCoreDlgs/FwCoreDlgsTests/AdvancedScriptRegionVariantModelTests.cs

@@ -293,7 +293,7 @@ public void GetStandardVariants_ListsLanguageSpecific()
 		{
 			var fwWsModel = new FwWritingSystemSetupModel(new TestWSContainer(new[] { "fr" }, new[] { "en" }), FwWritingSystemSetupModel.ListType.Vernacular);
 			var model = new AdvancedScriptRegionVariantModel(fwWsModel);
-			Assert.That("Early Modern French", Does.Contain(model.GetStandardVariants().Select(v => v.Name)));
+			Assert.That(model.GetStandardVariants().Select(v => v.Name), Does.Contain("Early Modern French"));
 		}
 
 		/// <summary/>
@@ -302,7 +302,7 @@ public void GetStandardVariants_ListsLanguageSpecificWithVariants()
 		{
 			var fwWsModel = new FwWritingSystemSetupModel(new TestWSContainer(new[] { "fr-x-extra" }, new[] { "en" }), FwWritingSystemSetupModel.ListType.Vernacular);
 			var model = new AdvancedScriptRegionVariantModel(fwWsModel);
-			Assert.That("Early Modern French", Does.Contain(model.GetStandardVariants().Select(v => v.Name)));
+			Assert.That(model.GetStandardVariants().Select(v => v.Name), Does.Contain("Early Modern French"));
 		}
 
 		/// <summary/>

Src/FwCoreDlgs/FwCoreDlgsTests/CnvtrPropertiesCtrlTests.cs

@@ -169,7 +169,6 @@ public void setCboConverter(ConverterType setTo)
 	[TestFixture]
 	public class CnvtrPropertiesControlTests
 	{
-		private DummyAddCnvtrDlg m_myDlg;
 		private DummyCnvtrPropertiesCtrl m_myCtrl;
 		private string m_ccFileName;
 		private string m_mapFileName;
@@ -185,17 +184,8 @@ public class CnvtrPropertiesControlTests
 		[OneTimeSetUp]
 		public void FixtureSetup()
 		{
-			var encConverters = new EncConverters();
-			// Remove any encoding converters we created that have been left over due to a crash
-			// or other mishap.  (That's why we use wierd names starting with ZZZUnitTest, so
-			// there won't be any conceivable conflict with user chosen names.  Inconceivable
-			// conflicts might still happen, but...)
-			RemoveTestConverters(encConverters, "Installed mappings before test setup:");
 			string[] ccFileContents = {"'c' > 'C'"};
 			m_ccFileName = CreateTempFile(ccFileContents, "cct");
-			encConverters.AddConversionMap("ZZZUnitTestCC", m_ccFileName,
-				ConvType.Legacy_to_Unicode, "SIL.cc", "", "",
-				ProcessTypeFlags.UnicodeEncodingConversion);
 
 			string[] mapFileContents = {
 										   "EncodingName	'ZZZUnitTestText'",
@@ -205,41 +195,17 @@ public void FixtureSetup()
 										   "0x80	<>	euro_sign"
 									   };
 			m_mapFileName = CreateTempFile(mapFileContents, "map");
-			encConverters.AddConversionMap("ZZZUnitTestMap", m_mapFileName,
-				ConvType.Legacy_to_from_Unicode, "SIL.map", "", "",
-				ProcessTypeFlags.UnicodeEncodingConversion);
-
-			// TODO: Should test a legitimate compiled TecKit file by embedding a zipped
-			// up one in the resources for testing purposes.
-
-			// This is a randomly chosen ICU converter. The test may break when we reduce the set of
-			// ICU converters we ship.
-			encConverters.AddConversionMap("ZZZUnitTestICU", "ISO-8859-1",
-				ConvType.Legacy_to_from_Unicode, "ICU.conv", "", "",
-				ProcessTypeFlags.ICUConverter);
-
-			// Add a 1-step compound converter, which won't be any of the types our dialog
-			// recognizes for now.
-			encConverters.AddCompoundConverterStep("ZZZUnitTestCompound", "ZZZUnitTestCC", true,
-				NormalizeFlags.None);
-
-			encConverters.Remove("BogusTecKitFile");	// shouldn't exist, but...
-
-			m_myDlg = new DummyAddCnvtrDlg();
 			m_myCtrl = new DummyCnvtrPropertiesCtrl();
-			m_myCtrl.Converters = encConverters;
-			// Load all the mappings after the dummy mappings are added, so the Converter
-			// Mapping File combo box won't contain obsolete versions of the mappings referring
-			// to old temp files from a previous run of the tests.q
-			m_myCtrl.CnvtrPropertiesCtrl_Load(null, null);
-#if !QUIET
-			Console.WriteLine("Installed mappings after test setup:");
-			foreach (var name in encConverters.Mappings)
+			m_myCtrl.UndefinedConverters = new System.Collections.Generic.Dictionary<string, EncoderInfo>
 			{
-				var conv = encConverters[name];
-				Console.WriteLine("    {0} ({1})", name, conv == null ? "null" : conv.GetType().ToString());
-			}
-#endif
+				{ "ZZZUnitTestCC", new EncoderInfo("ZZZUnitTestCC", ConverterType.ktypeCC, m_ccFileName, ConvType.Legacy_to_Unicode) },
+				{ "ZZZUnitTestMap", new EncoderInfo("ZZZUnitTestMap", ConverterType.ktypeTecKitMap, m_mapFileName, ConvType.Legacy_to_from_Unicode) },
+				{ "ZZZUnitTestICU", new EncoderInfo("ZZZUnitTestICU", ConverterType.ktypeIcuConvert, "ISO-8859-1", ConvType.Legacy_to_from_Unicode) },
+				// Use an unknown ConverterType value so it won't match any known ImplementType.
+				{ "ZZZUnitTestCompound", new EncoderInfo("ZZZUnitTestCompound", (ConverterType)9999, "", ConvType.Legacy_to_from_Unicode) },
+			};
+			// Populate UI comboboxes without touching EncConverters.
+			m_myCtrl.CnvtrPropertiesCtrl_Load(null, null);
 		}
 
 		/// <summary>
@@ -248,24 +214,11 @@ public void FixtureSetup()
 		[OneTimeTearDown]
 		public void FixtureTeardown()
 		{
-			EncConverters encConverters;
-			// Dispose managed resources here.
 			if (m_myCtrl != null)
 			{
-				encConverters = m_myCtrl.Converters;
 				m_myCtrl.Dispose();
 				m_myCtrl = null;
 			}
-			else
-			{
-				encConverters = new EncConverters();
-			}
-
-			if (m_myDlg != null)
-			{
-				m_myDlg.Dispose();
-				m_myDlg = null;
-			}
 
 			try
 			{
@@ -291,25 +244,6 @@ public void FixtureTeardown()
 				// for some reason deleting the temporary files occasionally fails - not sure
 				// why. If this happens we just ignore it and continue.
 			}
-
-			// Remove any encoding converters that we may have created during this test run.
-			RemoveTestConverters(encConverters, "Installed mappings after test teardown:");
-		}
-
-		void RemoveTestConverters(EncConverters encConverters, string testMessage)
-		{
-			// Remove any encoding converters that were added for these tests.
-			encConverters.Remove("ZZZUnitTestCC");
-			encConverters.Remove("ZZZUnitTestText");
-			encConverters.Remove("ZZZUnitTestMap");
-			encConverters.Remove("ZZZUnitTestICU");
-			encConverters.Remove("ZZZUnitTestCompound");
-			encConverters.Remove("ZZZUnitTestBogusTecKitFile");	// shouldn't exist, but...
-#if !QUIET
-			Console.WriteLine("{0}", testMessage);
-			foreach (var name in encConverters.Mappings)
-				Console.WriteLine("    {0}", name);
-#endif
 		}
 		#endregion
 
@@ -378,7 +312,6 @@ public void SelectMapping_TecKitMapTable()
 		[Test]
 		public void SelectMapping_IcuConversion()
 		{
-			var encConverterStoredType = m_myCtrl.Converters.GetMapByName("ZZZUnitTestICU").ConversionType;
 			m_myCtrl.SelectMapping("ZZZUnitTestICU");
 			Assert.That(m_myCtrl.cboConverter.SelectedItem is CnvtrTypeComboItem, Is.True, "Should be able to select ZZZUnitTestICU");
 			Assert.That(((CnvtrTypeComboItem)m_myCtrl.cboConverter.SelectedItem).Type, Is.EqualTo(ConverterType.ktypeIcuConvert), "Selected item should be ICU converter for ZZZUnitTestICU");
@@ -390,7 +323,7 @@ public void SelectMapping_IcuConversion()
 			// ICU converters we ship.
 			Assert.That(((CnvtrSpecComboItem)m_myCtrl.cboSpec.SelectedItem).Specs, Is.EqualTo("ISO-8859-1"), "Selected spec should be ISO-8859-1 for ZZZUnitTestICU");
 			Assert.That(m_myCtrl.cboConversion.SelectedItem is CnvtrDataComboItem, Is.True, "Conversion type should be selected for ZZZUnitTestICU");
-			Assert.That(((CnvtrDataComboItem)m_myCtrl.cboConversion.SelectedItem).Type, Is.EqualTo(encConverterStoredType), "Selected Conversion type should match the value stored in EncConverters for ZZZUnitTestICU");
+			Assert.That(((CnvtrDataComboItem)m_myCtrl.cboConversion.SelectedItem).Type, Is.EqualTo(ConvType.Legacy_to_from_Unicode), "Selected Conversion type should match the value stored for ZZZUnitTestICU");
 			Assert.That(m_myCtrl.txtName.Text, Is.EqualTo("ZZZUnitTestICU"), "Displayed converter should be ZZZUnitTestICU");
 		}
 
@@ -498,88 +431,6 @@ public void SelectMapping_PrepopulateCboConversion()
 			Assert.That(((CnvtrDataComboItem)m_myCtrl.cboConversion.SelectedItem).Type, Is.EqualTo(ConvType.Legacy_to_from_Unicode), "CodePage type defaults to Legacy_to_from_Unicode");
 		}
 
-		/// ------------------------------------------------------------------------------------
-		/// <summary>
-		/// Test a bogus compiled TecKit file. Should fail with nice error message, not crash.
-		/// </summary>
-		/// ------------------------------------------------------------------------------------
-		[Test]
-		public void SelectMapping_BogusCompiledTecKitFile()
-		{
-			m_bogusFileName = CreateTempFile(new string[] { "bogus contents" }, "tec");
-
-			// This is a type we don't recognize.
-			m_myDlg.m_cnvtrPropertiesCtrl.txtName.Text = "ZZZUnitTestBogusTecKitFile";
-
-			int i;
-			for (i = 0; i < m_myDlg.m_cnvtrPropertiesCtrl.cboConverter.Items.Count; ++i)
-			{
-				if (((CnvtrTypeComboItem)m_myDlg.m_cnvtrPropertiesCtrl.cboConverter.Items[i]).Type == ConverterType.ktypeTecKitTec)
-				{
-					m_myDlg.m_cnvtrPropertiesCtrl.cboConverter.SelectedIndex = i;
-					break;
-				}
-			}
-			Assert.That(i < m_myDlg.m_cnvtrPropertiesCtrl.cboConverter.Items.Count, Is.True, "Should find a TecKitTec type converter listed.");
-			for (i = 0; i < m_myDlg.m_cnvtrPropertiesCtrl.cboConversion.Items.Count; ++i)
-			{
-				if (((CnvtrDataComboItem)m_myDlg.m_cnvtrPropertiesCtrl.cboConversion.Items[i]).Type == ConvType.Legacy_to_Unicode)
-				{
-					m_myDlg.m_cnvtrPropertiesCtrl.cboConversion.SelectedIndex = i;
-					break;
-				}
-			}
-			Assert.That(i < m_myDlg.m_cnvtrPropertiesCtrl.cboConversion.Items.Count, Is.True, "Should find a Legacy_to_Unicode conversion listed.");
-
-			m_myDlg.SetMappingFile(m_bogusFileName);
-
-			Assert.That(m_myDlg.InstallConverter(), Is.False, "Should not be able to install bogus compiled TecKit file.");
-			// This may not be testing what we want it to test...
-			// Might want make an assert on the error message that is produced!
-		}
-
-		/// ------------------------------------------------------------------------------------
-		/// <summary>
-		/// Tests for a "successful" save when nothing is changed
-		/// </summary>
-		/// ------------------------------------------------------------------------------------
-		[Test]
-		public void AutoSave_ValidButUnchanged()
-		{
-			m_myDlg.m_cnvtrPropertiesCtrl.SelectMapping("ZZZUnitTestCC");
-			m_myDlg.SetUnchanged();
-			Assert.That(m_myDlg.AutoSave(), Is.True);
-		}
-
-		/// ------------------------------------------------------------------------------------
-		/// <summary>
-		/// Tests for a successful save when converter is valid
-		/// </summary>
-		/// ------------------------------------------------------------------------------------
-		[Test]
-		[Ignore("Fails about half of the time -- CameronB")]
-		public void AutoSave_ValidContents()
-		{
-			m_myDlg.m_cnvtrPropertiesCtrl.SelectMapping("ZZZUnitTestICU");
-			m_myDlg.SetUnchanged();
-			m_myDlg.m_cnvtrPropertiesCtrl.txtName.Text = "ZZZUnitTestRenamedICU";
-			Assert.That(m_myDlg.AutoSave(), Is.True);
-		}
-
-		/// ------------------------------------------------------------------------------------
-		/// <summary>
-		/// Tests for failure when converter cannot save successfully
-		/// </summary>
-		/// ------------------------------------------------------------------------------------
-		[Test]
-		[Ignore("Fails: producing object null message")]
-		public void AutoSave_InvalidContents()
-		{
-			m_myDlg.m_cnvtrPropertiesCtrl.SelectMapping("ZZZUnitTestMap");
-			m_myDlg.SetUnchanged();
-			m_myDlg.m_cnvtrPropertiesCtrl.cboSpec.Text = "NotValid";
-			Assert.That(m_myDlg.AutoSave(), Is.False);
-		}
 		#endregion
 
 		/// <summary>
@@ -593,7 +444,7 @@ string CreateTempFile(string[] data, string filetype)
 			{
 				filename = Path.ChangeExtension(fileTmp, filetype);
 				File.Move(fileTmp, filename);
-	}
+			}
 			using (var file = new StreamWriter(filename, false, System.Text.Encoding.ASCII))
 			{
 				foreach (var line in data)

Src/LexText/Interlinear/ITextDllTests/InterlinSfmImportTests.cs

@@ -9,9 +9,11 @@
 using System.Xml.Linq;
 using System.Xml.XPath;
 using NUnit.Framework;
+using Moq;
 using Sfm2Xml;
 using SIL.FieldWorks.LexText.Controls;
 using SilEncConverters40;
+using ECInterfaces;
 using SIL.LCModel.Core.WritingSystems;
 
 namespace SIL.FieldWorks.IText
@@ -165,10 +167,15 @@ public void BasicConversion()
 		[Test]
 		public void EncodingConverters()
 		{
-			var encConv = new EncConverters();
-			encConv.AddConversionMap("XXYTestConverter", "1252",
-						ECInterfaces.ConvType.Legacy_to_from_Unicode, "cp", "", "",
-						ECInterfaces.ProcessTypeFlags.CodePageConversion);
+			var mockConverter = new Mock<IEncConverter>();
+			mockConverter
+				.Setup(c => c.ConvertToUnicode(It.IsAny<byte[]>()))
+				.Returns((byte[] bytes) => Encoding.GetEncoding(1252).GetString(bytes));
+
+			var mockEncConverters = new Mock<IEncConverters>();
+			mockEncConverters.Setup(c => c[It.IsAny<string>()]).Returns((IEncConverter)null);
+			mockEncConverters.Setup(c => c["XXYTestConverter"]).Returns(mockConverter.Object);
+
 			var mappings = new List<InterlinearMapping>();
 			mappings.Add(new InterlinearMapping()
 							{
@@ -186,7 +193,7 @@ public void EncodingConverters()
 			});
 			var wsf = GetWsf();
 			var input = new ByteReader("input2", Encoding.GetEncoding(1252).GetBytes(input2));
-			var converter = new Sfm2FlexText();
+			var converter = new Sfm2FlexText(mockEncConverters.Object);
 			var output = converter.Convert(input, mappings, wsf);
 			using (var outputStream = new MemoryStream(output))
 			{
@@ -198,7 +205,6 @@ public void EncodingConverters()
 					var phrase1 = textElt.XPathSelectElement("./paragraphs/paragraph/phrases/phrase");
 					VerifyText(phrase1, new[] { "John", "added", "this\x017D" },
 						new HashSet<string>(), "qaa-x-kal");
-					encConv.Remove("XXYTestConverter");
 				}
 			}
 		}

Src/LexText/Interlinear/Sfm2FlexText.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using ECInterfaces;
 using SIL.LCModel.Core.Text;
 using SIL.FieldWorks.LexText.Controls;
 using SIL.LCModel.DomainServices;
@@ -33,6 +34,11 @@ internal Sfm2FlexText() : base (new List<string>(new [] { "document", "interline
 		{
 		}
 
+		internal Sfm2FlexText(IEncConverters encConverters) : base(new List<string>(new[] { "document", "interlinear-text",
+			"paragraphs", "paragraph", "phrases", "phrase", "words", "word" }), encConverters)
+		{
+		}
+
 		protected override void WriteToDocElement(byte[] data, InterlinearMapping mapping)
 		{
 			switch (mapping.Destination)