v2_39_0

Adaptation/.vscode/launch.json

@@ -4,7 +4,7 @@
       "name": ".NET Core Attach",
       "type": "coreclr",
       "request": "attach",
-      "processId": 68192
+      "processId": 13824
     }
   ]
 }

Adaptation/Shared/Metrology/WS.cs

@@ -16,7 +16,7 @@ public partial class WS
         try
         {
             string json = JsonSerializer.Serialize(payload, payload.GetType());
-            if (string.IsNullOrEmpty(url) || !url.Contains(':') || !url.Contains('.'))
+            if (string.IsNullOrEmpty(url) || !url.Contains(":") || !url.Contains("."))
                 throw new Exception("Invalid URL");
             using (HttpClient httpClient = new())
             {

Adaptation/_Tests/CreateSelfDescription/Staging/v2.39.0/CDE2.cs

@@ -0,0 +1,50 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shared;
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace _Tests.CreateSelfDescription.Staging.v2_39_0;
+
+[TestClass]
+public class CDE2 : EAFLoggingUnitTesting
+{
+    internal static CDE2 EAFLoggingUnitTesting { get; private set; }
+
+    public CDE2() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public CDE2(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        if (EAFLoggingUnitTesting is null)
+            EAFLoggingUnitTesting = new CDE2(testContext);
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(testContext.TestName, " - ClassInitialize"));
+        string[] fileNameAndText = EAFLoggingUnitTesting.AdaptationTesting.GetCSharpText(testContext.TestName);
+        File.WriteAllText(fileNameAndText[0], fileNameAndText[1]);
+        File.WriteAllText(fileNameAndText[2], fileNameAndText[3]);
+    }
+
+    [ClassCleanup()]
+    public static void ClassCleanup()
+    {
+        if (EAFLoggingUnitTesting.Logger is not null)
+            EAFLoggingUnitTesting.Logger.LogInformation("Cleanup");
+        if (EAFLoggingUnitTesting is not null)
+            EAFLoggingUnitTesting.Dispose();
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE2__()
+    {
+    }
+
+}

Adaptation/_Tests/CreateSelfDescription/Staging/v2.39.0/CDE3-EQPT.cs

@@ -0,0 +1,61 @@
+using Adaptation.Shared.Methods;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shared;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+namespace _Tests.CreateSelfDescription.Staging.v2_39_0;
+
+[TestClass]
+public class CDE3_EQPT : EAFLoggingUnitTesting
+{
+    internal static CDE3_EQPT EAFLoggingUnitTesting { get; private set; }
+
+    public CDE3_EQPT() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public CDE3_EQPT(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        if (EAFLoggingUnitTesting is null)
+            EAFLoggingUnitTesting = new CDE3_EQPT(testContext);
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(testContext.TestName, " - ClassInitialize"));
+        string[] fileNameAndText = EAFLoggingUnitTesting.AdaptationTesting.GetCSharpText(testContext.TestName);
+        File.WriteAllText(fileNameAndText[0], fileNameAndText[1]);
+        File.WriteAllText(fileNameAndText[2], fileNameAndText[3]);
+    }
+
+    [ClassCleanup()]
+    public static void ClassCleanup()
+    {
+        if (EAFLoggingUnitTesting.Logger is not null)
+            EAFLoggingUnitTesting.Logger.LogInformation("Cleanup");
+        if (EAFLoggingUnitTesting is not null)
+            EAFLoggingUnitTesting.Dispose();
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE3_EQPT__DownloadRsMFile()
+    {
+        string check = "WafrMeas.log|.RsM";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+}

Adaptation/_Tests/CreateSelfDescription/Staging/v2.39.0/CDE3.cs

@@ -0,0 +1,61 @@
+using Adaptation.Shared.Methods;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shared;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+namespace _Tests.CreateSelfDescription.Staging.v2_39_0;
+
+[TestClass]
+public class CDE3 : EAFLoggingUnitTesting
+{
+    internal static CDE3 EAFLoggingUnitTesting { get; private set; }
+
+    public CDE3() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public CDE3(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        if (EAFLoggingUnitTesting is null)
+            EAFLoggingUnitTesting = new CDE3(testContext);
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(testContext.TestName, " - ClassInitialize"));
+        string[] fileNameAndText = EAFLoggingUnitTesting.AdaptationTesting.GetCSharpText(testContext.TestName);
+        File.WriteAllText(fileNameAndText[0], fileNameAndText[1]);
+        File.WriteAllText(fileNameAndText[2], fileNameAndText[3]);
+    }
+
+    [ClassCleanup()]
+    public static void ClassCleanup()
+    {
+        if (EAFLoggingUnitTesting.Logger is not null)
+            EAFLoggingUnitTesting.Logger.LogInformation("Cleanup");
+        if (EAFLoggingUnitTesting is not null)
+            EAFLoggingUnitTesting.Dispose();
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE3__RsM()
+    {
+        string check = "*.RsM";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+}

Adaptation/_Tests/CreateSelfDescription/Staging/v2.39.0/CDE5.cs

@@ -0,0 +1,55 @@
+using Adaptation.Shared;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shared;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+using System.Threading;
+
+namespace _Tests.CreateSelfDescription.Staging.v2_39_0;
+
+[TestClass]
+public class CDE5 : EAFLoggingUnitTesting
+{
+    internal static CDE5 EAFLoggingUnitTesting { get; private set; }
+
+    public CDE5() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public CDE5(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        if (EAFLoggingUnitTesting is null)
+            EAFLoggingUnitTesting = new CDE5(testContext);
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(testContext.TestName, " - ClassInitialize"));
+        string[] fileNameAndText = EAFLoggingUnitTesting.AdaptationTesting.GetCSharpText(testContext.TestName);
+        File.WriteAllText(fileNameAndText[0], fileNameAndText[1]);
+        File.WriteAllText(fileNameAndText[2], fileNameAndText[3]);
+    }
+
+    [ClassCleanup()]
+    public static void ClassCleanup()
+    {
+        if (EAFLoggingUnitTesting.Logger is not null)
+            EAFLoggingUnitTesting.Logger.LogInformation("Cleanup");
+        if (EAFLoggingUnitTesting is not null)
+            EAFLoggingUnitTesting.Dispose();
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE5__()
+    {
+    }
+
+}

Adaptation/_Tests/CreateSelfDescription/Staging/v2.39.0/MET08RESIMAPCDE.cs

@@ -0,0 +1,173 @@
+using Adaptation.Shared.Methods;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shared;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+namespace _Tests.CreateSelfDescription.Staging.v2_39_0;
+
+[TestClass]
+public class MET08RESIMAPCDE : EAFLoggingUnitTesting
+{
+    internal static MET08RESIMAPCDE EAFLoggingUnitTesting { get; private set; }
+
+    public MET08RESIMAPCDE() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public MET08RESIMAPCDE(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        if (EAFLoggingUnitTesting is null)
+            EAFLoggingUnitTesting = new MET08RESIMAPCDE(testContext);
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(testContext.TestName, " - ClassInitialize"));
+        string[] fileNameAndText = EAFLoggingUnitTesting.AdaptationTesting.GetCSharpText(testContext.TestName);
+        File.WriteAllText(fileNameAndText[0], fileNameAndText[1]);
+        File.WriteAllText(fileNameAndText[2], fileNameAndText[3]);
+    }
+
+    [ClassCleanup()]
+    public static void ClassCleanup()
+    {
+        if (EAFLoggingUnitTesting.Logger is not null)
+            EAFLoggingUnitTesting.Logger.LogInformation("Cleanup");
+        if (EAFLoggingUnitTesting is not null)
+            EAFLoggingUnitTesting.Dispose();
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE()
+    {
+        string check = "~IsXToOpenInsightMetrologyViewer";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_()
+    {
+        string check = "~IsXToIQSSi";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE__()
+    {
+        string check = "~IsXToOpenInsight";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE___()
+    {
+        string check = "~IsXToOpenInsightMetrologyViewerAttachments";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE____()
+    {
+        string check = "~IsXToAPC";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_____()
+    {
+        string check = "~IsXToSPaCe";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE______()
+    {
+        string check = "~IsXToArchive";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_______()
+    {
+        string check = "~IsArchive";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE________()
+    {
+        string check = "~IsDummy";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        string[] fileNameAndJson = EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);
+        Assert.IsTrue(fileNameAndJson[1].Contains(check));
+        File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);
+        IFileRead fileRead = EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);
+        Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+}

Adaptation/_Tests/Extract/Staging/v2.39.0/CDE3-EQPT.cs

@@ -0,0 +1,29 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Methods;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+
+namespace _Tests.Extract.Staging.v2_39_0;
+
+[TestClass]
+public class CDE3_EQPT
+{
+
+    private static CreateSelfDescription.Staging.v2_39_0.CDE3_EQPT _CDE3_EQPT;
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        CreateSelfDescription.Staging.v2_39_0.CDE3_EQPT.ClassInitialize(testContext);
+        _CDE3_EQPT = CreateSelfDescription.Staging.v2_39_0.CDE3_EQPT.EAFLoggingUnitTesting;
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE3_EQPT__DownloadRsMFile() => _CDE3_EQPT.Staging__v2_39_0__CDE3_EQPT__DownloadRsMFile();
+
+}

Adaptation/_Tests/Extract/Staging/v2.39.0/CDE3.cs

@@ -0,0 +1,84 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Methods;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+
+namespace _Tests.Extract.Staging.v2_39_0;
+
+[TestClass]
+public class CDE3
+{
+
+    private static CreateSelfDescription.Staging.v2_39_0.CDE3 _CDE3;
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        CreateSelfDescription.Staging.v2_39_0.CDE3.ClassInitialize(testContext);
+        _CDE3 = CreateSelfDescription.Staging.v2_39_0.CDE3.EAFLoggingUnitTesting;
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE3__RsM() => _CDE3.Staging__v2_39_0__CDE3__RsM();
+
+    [TestMethod]
+    public void Staging__v2_39_0__CDE3__RsM643047560320000000__Normal()
+    {
+        DateTime dateTime;
+        string check = "*.RsM";
+        _CDE3.Staging__v2_39_0__CDE3__RsM();
+        MethodBase methodBase = new StackFrame().GetMethod();
+        string[] variables = _CDE3.AdaptationTesting.GetVariables(methodBase, check);
+        Tuple<string, string[], string[]> pdsf = Helpers.Metrology.GetLogisticsColumnsAndBody(variables[2], variables[4]);
+        IFileRead fileRead = _CDE3.AdaptationTesting.Get(methodBase, sourceFileLocation: variables[2], sourceFileFilter: variables[3], useCyclicalForDescription: false);
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResult = fileRead.ReExtract();
+        Assert.IsFalse(string.IsNullOrEmpty(extractResult?.Item1));
+        Assert.IsTrue(extractResult.Item3.Length > 0, "extractResult Array Length check!");
+        Assert.IsNotNull(extractResult.Item4);
+        Logistics logistics = new(fileRead);
+        dateTime = Adaptation.FileHandlers.RsM.ProcessData.GetDateTime(logistics, string.Empty);
+        Assert.IsTrue(dateTime == logistics.DateTimeFromSequence);
+        dateTime = Adaptation.FileHandlers.RsM.ProcessData.GetDateTime(logistics, "00:13 09/27/38");
+        Assert.IsTrue(dateTime == logistics.DateTimeFromSequence);
+        string logBody = @"
+RUN	[59-478796-3978.1]
+Recipe	LSL_6in \ WACKER2	RESISTIVITY SPEC
+EQUIP#	ResMap	Engineer	Engineer
+LotID	LotID	D.L.RATIO	0.9950
+OPERATOR	Operator	TEMP	19.4	00:13 09/27/38
+AutoOptimizeGain = YES	AutoProbeHeightSet = NO
+DataReject > 3.0Sigma
+0	C:\4p_NT\LSL_6in.prj\WACKER2.rcp\8927A117.RsM	00:13 09/27/38
+pt#	R	Th	Rs[Ohm/sq@T]	Merit
+1	65.0	-44.5	577.7672	77.79
+2	32.5	-44.5	572.4527	102.7
+3	0.0	0.5	581.8071	108.0
+4	-32.5	-44.5	576.9838	93.04
+5	-65.0	-44.5	577.0866	69.79
+Avg =	577.2195	0.58%	SEMI Radial= 0.81%
+            ";
+        bool logBodyCheck = logBody.Trim() == extractResult.Item1.Trim();
+        if (!logBodyCheck)
+        {
+            _ = Process.Start("explorer.exe", variables[5]);
+            File.WriteAllText(Path.Combine(variables[5], $"{Path.GetFileName(variables[5])}.log"), extractResult.Item1);
+        }
+        Assert.IsTrue(logBodyCheck, "Log Body doesn't match!");
+        Tuple<string, string[], string[]> pdsfNew = Helpers.Metrology.GetLogisticsColumnsAndBody(fileRead, logistics, extractResult, pdsf);
+        Helpers.Metrology.CompareSave(variables[5], pdsf, pdsfNew);
+        Assert.IsTrue(pdsf.Item1 == pdsfNew.Item1, "Item1 check!");
+        string[] json = Helpers.Metrology.GetItem2(pdsf, pdsfNew);
+        Helpers.Metrology.CompareSaveJSON(variables[5], json);
+        Assert.IsTrue(json[0] == json[1], "Item2 check!");
+        string[] join = Helpers.Metrology.GetItem3(pdsf, pdsfNew);
+        Helpers.Metrology.CompareSaveTSV(variables[5], join);
+        Assert.IsTrue(join[0] == join[1], "Item3 (Join) check!");
+        Helpers.Metrology.UpdatePassDirectory(variables[2]);
+    }
+
+}

Adaptation/_Tests/Extract/Staging/v2.39.0/MET08RESIMAPCDE.cs

@@ -0,0 +1,79 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Methods;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+
+namespace _Tests.Extract.Staging.v2_39_0;
+
+[TestClass]
+public class MET08RESIMAPCDE
+{
+
+    private static CreateSelfDescription.Staging.v2_39_0.MET08RESIMAPCDE _MET08RESIMAPCDE;
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        CreateSelfDescription.Staging.v2_39_0.MET08RESIMAPCDE.ClassInitialize(testContext);
+        _MET08RESIMAPCDE = CreateSelfDescription.Staging.v2_39_0.MET08RESIMAPCDE.EAFLoggingUnitTesting;
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE637710931421087642__Normal()
+    {
+        string check = "~IsXToOpenInsightMetrologyViewer";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE();
+        string[] variables = _MET08RESIMAPCDE.AdaptationTesting.GetVariables(methodBase, check);
+        Tuple<string, string[], string[]> pdsf = Helpers.Metrology.GetLogisticsColumnsAndBody(variables[2], variables[4]);
+        IFileRead fileRead = _MET08RESIMAPCDE.AdaptationTesting.Get(methodBase, sourceFileLocation: variables[2], sourceFileFilter: variables[3], useCyclicalForDescription: false);
+        Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResult = fileRead.ReExtract();
+        Assert.IsFalse(string.IsNullOrEmpty(extractResult?.Item1));
+        Assert.IsTrue(extractResult.Item3.Length > 0, "extractResult Array Length check!");
+        Assert.IsNotNull(extractResult.Item4);
+        Logistics logistics = new(fileRead);
+        Tuple<string, string[], string[]> pdsfNew = Helpers.Metrology.GetLogisticsColumnsAndBody(fileRead, logistics, extractResult, pdsf);
+        Helpers.Metrology.CompareSave(variables[5], pdsf, pdsfNew);
+        Assert.IsTrue(pdsf.Item1 == pdsfNew.Item1, "Item1 check!");
+        string[] json = Helpers.Metrology.GetItem2(pdsf, pdsfNew);
+        Helpers.Metrology.CompareSaveJSON(variables[5], json);
+        Assert.IsTrue(json[0] == json[1], "Item2 check!");
+        string[] join = Helpers.Metrology.GetItem3(pdsf, pdsfNew);
+        Helpers.Metrology.CompareSaveTSV(variables[5], join);
+        Assert.IsTrue(join[0] == join[1], "Item3 (Join) check!");
+        Helpers.Metrology.UpdatePassDirectory(variables[2]);
+    }
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE__() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE__();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE___() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE___();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE____() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE____();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_____() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_____();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE______() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE______();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_______() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE_______();
+
+    [TestMethod]
+    public void Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE________() => _MET08RESIMAPCDE.Staging__v2_39_0__MET08RESIMAPCDE__MET08RESIMAPCDE________();
+
+}

Adaptation/package.json

@@ -5,14 +5,14 @@
         "dotnet-format": "dotnet format --report .vscode --verbosity detailed --severity warn",
         "pull": "git pull",
         "garbage-collect": "git gc",
-        "AA-CreateSelfDescription.Staging.v2_39_0-CDE3_EQPT-Staging__v2_39_0__CDE3_EQPT__MoveDLGFile": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~CDE3_EQPT & Staging__v2_39_0__CDE3_EQPT__MoveDLGFile\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
+        "AA-CreateSelfDescription.Staging.v2_39_0-CDE3_EQPT-Staging__v2_39_0__CDE3_EQPT__DownloadRsMFile": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~CDE3_EQPT & Staging__v2_39_0__CDE3_EQPT__DownloadRsMFile\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "AT-CreateSelfDescription.Staging.v2_39_0-MET08RESIMAPCDE": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~MET08RESIMAPCDE\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "AV-CreateSelfDescription.Staging.v2_39_0-CDE2_EQPT": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~CDE2_EQPT\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "AW-CreateSelfDescription.Staging.v2_39_0-CDE2": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~CDE2\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "AX-CreateSelfDescription.Staging.v2_39_0-CDE3_EQPT": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~CDE3_EQPT\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "AY-CreateSelfDescription.Staging.v2_39_0-CDE3": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0 & ClassName~CDE3\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "AZ-CreateSelfDescription.Staging.v2_39_0": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.CreateSelfDescription.Staging.v2_39_0\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
-        "BA-Extract.Staging.v2_39_0-CDE3-Staging__v2_39_0__CDE3__cac637535051877475932__Etch": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.Extract.Staging.v2_39_0 & ClassName~CDE3 & Staging__v2_39_0__CDE3__cac637535051877475932__Etch\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
+        "BA-Extract.Staging.v2_39_0-CDE3-Staging__v2_39_0__CDE3__RsM643047560320000000__Normal": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.Extract.Staging.v2_39_0 & ClassName~CDE3 & Staging__v2_39_0__CDE3__RsM643047560320000000__Normal\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "BT-Extract.Staging.v2_39_0-MET08RESIMAPCDE": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.Extract.Staging.v2_39_0 & ClassName~MET08RESIMAPCDE\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "BV-Extract.Staging.v2_39_0-CDE2_EQPT": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.Extract.Staging.v2_39_0 & ClassName~CDE2_EQPT\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",
         "BW-Extract.Staging.v2_39_0-CDE2": "dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.Extract.Staging.v2_39_0 & ClassName~CDE2\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")",

Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.36.1.0")]
+[assembly: AssemblyVersion("2.39.0.0")]
-[assembly: AssemblyFileVersion("2.36.1.0")]
+[assembly: AssemblyFileVersion("2.39.0.0")]