Refactor ProcessDataStandardFormat and add unit tests for v2.61.1

- Updated GetPDSFText method to accept nullable logisticsText parameter.
- Removed unused TryGetPropertyIndex method from ProcessDataStandardFormat.
- Introduced new unit tests for CreateSelfDescription and Extract functionalities in version 2.61.1.
- Implemented logging and file handling in the test classes to ensure proper setup and teardown.

Adaptation/FileHandlers/TIBCO/Transport/Job.cs

@@ -719,7 +719,59 @@ public partial class Job
     private static string GetCommandText(CommonB commonB, string jobNames)
     { // cSpell:disable
         List<string> results = new();
-        results.Add(" select count(distinct(se.f_sgrp)) count_se_sgrp ");
+        results.Add(" select count(1) ");
+        results.Add(" from ( ");
+        results.Add("   select [sid] ");
+        results.Add("         , [lot] ");
+        results.Add("         , [process] ");
+        results.Add("         , [part] ");
+        results.Add("         , [job] ");
+        results.Add("         , ( ");
+        results.Add("             select min(concat( ");
+        results.Add("                    case when sd.f_dsgp = 1729787380 /* CDE SetupFile */ ");
+        results.Add("                    then ds.f_name ");
+        results.Add("                    else '' ");
+        results.Add("                    end, ");
+        results.Add("                    case when sd.f_dsgp = 1657296864 /* CDE Pattern */ ");
+        results.Add("                    then ds.f_name ");
+        results.Add("                    else '' ");
+        results.Add("                    end, ");
+        results.Add("                    case when sd.f_dsgp = 1655312695 /* BioRad, BioRad Stratus, CDE, SP1, TBI and Tencor - Recipe */ ");
+        results.Add("                    then ds.f_name ");
+        results.Add("                    else '' ");
+        results.Add("                    end)) ");
+        results.Add("           from [spcepiworld].[dbo].[sgrp_dsc] sd ");
+        results.Add("           join [spcepiworld].[dbo].[desc_dat] ds ");
+        results.Add("             on sd.f_desc = ds.f_desc ");
+        results.Add("           where [sid] = sd.f_sgrp ");
+        results.Add("             and sd.f_dsgp in (1729787380, 1657296864, 1655312695) ");
+        results.Add("         ) [min recipe] ");
+        results.Add("         , ( ");
+        results.Add("             select max(concat( ");
+        results.Add("                    case when sd.f_dsgp = 1729787380 /* CDE SetupFile */ ");
+        results.Add("                    then ds.f_name ");
+        results.Add("                    else '' ");
+        results.Add("                    end, ");
+        results.Add("                    case when sd.f_dsgp = 1657296864 /* CDE Pattern */ ");
+        results.Add("                    then ds.f_name ");
+        results.Add("                    else '' ");
+        results.Add("                    end, ");
+        results.Add("                    case when sd.f_dsgp = 1655312695 /* BioRad, BioRad Stratus, CDE, SP1, TBI and Tencor - Recipe */ ");
+        results.Add("                    then ds.f_name ");
+        results.Add("                    else '' ");
+        results.Add("                    end)) ");
+        results.Add("           from [spcepiworld].[dbo].[sgrp_dsc] sd ");
+        results.Add("           join [spcepiworld].[dbo].[desc_dat] ds ");
+        results.Add("             on sd.f_desc = ds.f_desc ");
+        results.Add("           where [sid] = sd.f_sgrp ");
+        results.Add("             and sd.f_dsgp in (1729787380, 1657296864, 1655312695) ");
+        results.Add("         ) [max recipe] ");
+        results.Add("   from ( ");
+        results.Add("     select se.f_sgrp [sid] ");
+        results.Add("         , pl.f_name [lot] ");
+        results.Add("         , pr.f_name [process] ");
+        results.Add("         , pd.f_name [part] ");
+        results.Add("         , jd.f_name [job] ");
         results.Add("     from [spcepiworld].[dbo].[sgrp_ext] se ");
         results.Add("     join [spcepiworld].[dbo].[prcs_dat] pr ");
         results.Add("       on se.f_prcs = pr.f_prcs ");
@@ -736,6 +788,21 @@ public partial class Job
         results.Add($"      and pr.f_name = '{commonB.ReactorNumber}' ");
         results.Add($"      and pd.f_name = '{commonB.PSN}' ");
         results.Add($"      and jd.f_name in ({jobNames}) ");
+        results.Add("     group by se.f_sgrp ");
+        results.Add("           , se.f_sgtm ");
+        results.Add("           , pl.f_name ");
+        results.Add("           , pr.f_name ");
+        results.Add("           , pd.f_name ");
+        results.Add("           , jd.f_name ");
+        results.Add("   ) iq ");
+        results.Add(" ) iq ");
+        results.Add(" group by [lot] ");
+        results.Add("        , [process] ");
+        results.Add("        , [part] ");
+        results.Add("        , [job] ");
+        results.Add("        , [min recipe] ");
+        results.Add("        , [max recipe] ");
+        results.Add(" ; ");
         return string.Join(Environment.NewLine, results);
     } // cSpell:restore
 

Adaptation/FileHandlers/txt/Constant.cs

@@ -17,6 +17,8 @@ internal class Constant
     public string Reject { get; } = "F                  Reject";
     public string LongWaferSummary { get; } = "Long Wafer Summary";
     public string OverLoad { get; } = "F                  OverLoad";
+    public string ShortWaferSummary { get; } = "Short Wafer Summary";
     public string Empty35Spaces { get; } = "                                   ";
+    public string FormatExceptionMessage { get; } = "Wafer Summary section is neither Short nor Long format.";
 
 }

Adaptation/FileHandlers/txt/Header.cs

@@ -69,7 +69,10 @@ public class Header
         Header result;
         string lot;
         string session;
+        if (!text.Contains(constant.ShortWaferSummary))
             ScanPast(text, i, constant.LongWaferSummary);
+        else
+            ScanPast(text, i, constant.ShortWaferSummary);
         _ = GetToEOL(text, i);
         ScanPast(text, i, constant.Session);
         session = GetToEOL(text, i, true);

Adaptation/FileHandlers/txt/Summary.cs

@@ -765,7 +765,20 @@ public class Summary
             waferSummaryInfo.WaferID = segments[1];
             waferSummaryInfo.Grade = segments[2];
             waferSummaryInfo.SrcDest = segments[3];
-            if (segments.Length > 4)
+            if (segments.Length > 8)
+            {
+                if (text.Contains(constant.ShortWaferSummary))
+                {
+                    waferSummaryInfo.Lpd = segments[5];
+                    waferSummaryInfo.LpdN = segments[6];
+                    waferSummaryInfo.LpdES = segments[7];
+                    waferSummaryInfo.MicroScr = segments[8];
+                    waferSummaryInfo.Scr = segments[9];
+                    waferSummaryInfo.Slip = segments[10];
+                    waferSummaryInfo.AreaNum = segments[11];
+                    waferSummaryInfo.Area = segments[12];
+                }
+                else if (text.Contains(constant.LongWaferSummary))
                 {
                     waferSummaryInfo.Lpd = segments[5];
                     waferSummaryInfo.LpdN = segments[6];
@@ -787,6 +800,9 @@ public class Summary
                     waferSummaryInfo.Bin7 = segments[22];
                     waferSummaryInfo.Bin8 = segments[23];
                 }
+                else
+                    throw new Exception(constant.FormatExceptionMessage);
+            }
             if (waferSummaryInfo.WaferID == "-1")
             {
                 segments = waferSummaryInfo.SrcDest.Split('-')[0].Split('/');
@@ -858,6 +874,252 @@ public class Summary
             Header.ScanPast(text, i, constant.StdDev);
             dnnTotalsStandardDevSegments = Header.GetToEOL(text, i).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
         }
+        if (text.Contains(constant.ShortWaferSummary))
+        {
+            result = new(dcnAllMin: dncTotalsMinSegments[0],
+                         dcnLpdMin: dncTotalsMinSegments[1],
+                         dcnLpdNMin: dncTotalsMinSegments[2],
+                         dcnLpdESMin: dncTotalsMinSegments[3],
+                         dcnMicroScrMin: dncTotalsMinSegments[4],
+                         dcnScrMin: dncTotalsMinSegments[5],
+                         dcnSlipMin: dncTotalsMinSegments[6],
+                         dcnAreaCountMin: dncTotalsMinSegments[7],
+                         dcnAreaMin: dncTotalsMinSegments[8],
+                         dcnHazeAvgMin: string.Empty,
+                         dcnHazeMedianMin: string.Empty,
+                         dcnHazeStdDevMin: string.Empty,
+                         dcnBin1Min: string.Empty,
+                         dcnBin2Min: string.Empty,
+                         dcnBin3Min: string.Empty,
+                         dcnBin4Min: string.Empty,
+                         dcnBin5Min: string.Empty,
+                         dcnBin6Min: string.Empty,
+                         dcnBin7Min: string.Empty,
+                         dcnBin8Min: string.Empty,
+                         dcnAllMax: dncTotalsMaxSegments[0],
+                         dcnLpdMax: dncTotalsMaxSegments[1],
+                         dcnLpdNMax: dncTotalsMaxSegments[2],
+                         dcnLpdESMax: dncTotalsMaxSegments[3],
+                         dcnMicroScrMax: dncTotalsMaxSegments[4],
+                         dcnScrMax: dncTotalsMaxSegments[5],
+                         dcnSlipMax: dncTotalsMaxSegments[6],
+                         dcnAreaCountMax: dncTotalsMaxSegments[7],
+                         dcnAreaMax: dncTotalsMaxSegments[8],
+                         dcnHazeAvgMax: string.Empty,
+                         dcnHazeMedianMax: string.Empty,
+                         dcnHazeStdDevMax: string.Empty,
+                         dcnBin1Max: string.Empty,
+                         dcnBin2Max: string.Empty,
+                         dcnBin3Max: string.Empty,
+                         dcnBin4Max: string.Empty,
+                         dcnBin5Max: string.Empty,
+                         dcnBin6Max: string.Empty,
+                         dcnBin7Max: string.Empty,
+                         dcnBin8Max: string.Empty,
+                         dcnAllMean: dncTotalsMeanSegments[0],
+                         dcnLpdMean: dncTotalsMeanSegments[1],
+                         dcnLpdNMean: dncTotalsMeanSegments[2],
+                         dcnLpdESMean: dncTotalsMeanSegments[3],
+                         dcnMicroScrMean: dncTotalsMeanSegments[4],
+                         dcnScrMean: dncTotalsMeanSegments[5],
+                         dcnSlipMean: dncTotalsMeanSegments[6],
+                         dcnAreaCountMean: dncTotalsMeanSegments[7],
+                         dcnAreaMean: dncTotalsMeanSegments[8],
+                         dcnHazeAvgMean: string.Empty,
+                         dcnHazeMedianMean: string.Empty,
+                         dcnHazeStdDevMean: string.Empty,
+                         dcnBin1Mean: string.Empty,
+                         dcnBin2Mean: string.Empty,
+                         dcnBin3Mean: string.Empty,
+                         dcnBin4Mean: string.Empty,
+                         dcnBin5Mean: string.Empty,
+                         dcnBin6Mean: string.Empty,
+                         dcnBin7Mean: string.Empty,
+                         dcnBin8Mean: string.Empty,
+                         dcnAllStdDev: dncTotalsStandardDevSegments[0],
+                         dcnLpdStdDev: dncTotalsStandardDevSegments[1],
+                         dcnLpdNStdDev: dncTotalsStandardDevSegments[2],
+                         dcnLpdESStdDev: dncTotalsStandardDevSegments[3],
+                         dcnMicroScrStdDev: dncTotalsStandardDevSegments[4],
+                         dcnScrStdDev: dncTotalsStandardDevSegments[5],
+                         dcnSlipStdDev: dncTotalsStandardDevSegments[6],
+                         dcnAreaCountStdDev: dncTotalsStandardDevSegments[7],
+                         dcnAreaStdDev: dncTotalsStandardDevSegments[8],
+                         dcnHazeAvgStdDev: string.Empty,
+                         dcnHazeMedianStdDev: string.Empty,
+                         dcnHazeStdDevStdDev: string.Empty,
+                         dcnBin1StdDev: string.Empty,
+                         dcnBin2StdDev: string.Empty,
+                         dcnBin3StdDev: string.Empty,
+                         dcnBin4StdDev: string.Empty,
+                         dcnBin5StdDev: string.Empty,
+                         dcnBin6StdDev: string.Empty,
+                         dcnBin7StdDev: string.Empty,
+                         dcnBin8StdDev: string.Empty,
+                         dwnAllMin: dwnTotalsMinSegments[0],
+                         dwnLpdMin: dwnTotalsMinSegments[1],
+                         dwnLpdNMin: dwnTotalsMinSegments[2],
+                         dwnLpdESMin: dwnTotalsMinSegments[3],
+                         dwnMicroScrMin: dwnTotalsMinSegments[4],
+                         dwnScrMin: dwnTotalsMinSegments[5],
+                         dwnSlipMin: dwnTotalsMinSegments[6],
+                         dwnAreaCountMin: dwnTotalsMinSegments[7],
+                         dwnAreaMin: dwnTotalsMinSegments[8],
+                         dwnHazeAvgMin: string.Empty,
+                         dwnHazeMedianMin: string.Empty,
+                         dwnHazeStdDevMin: string.Empty,
+                         dwnBin1Min: string.Empty,
+                         dwnBin2Min: string.Empty,
+                         dwnBin3Min: string.Empty,
+                         dwnBin4Min: string.Empty,
+                         dwnBin5Min: string.Empty,
+                         dwnBin6Min: string.Empty,
+                         dwnBin7Min: string.Empty,
+                         dwnBin8Min: string.Empty,
+                         dwnAllMax: dwnTotalsMaxSegments[0],
+                         dwnLpdMax: dwnTotalsMaxSegments[1],
+                         dwnLpdNMax: dwnTotalsMaxSegments[2],
+                         dwnLpdESMax: dwnTotalsMaxSegments[3],
+                         dwnMicroScrMax: dwnTotalsMaxSegments[4],
+                         dwnScrMax: dwnTotalsMaxSegments[5],
+                         dwnSlipMax: dwnTotalsMaxSegments[6],
+                         dwnAreaCountMax: dwnTotalsMaxSegments[7],
+                         dwnAreaMax: dwnTotalsMaxSegments[8],
+                         dwnHazeAvgMax: string.Empty,
+                         dwnHazeMedianMax: string.Empty,
+                         dwnHazeStdDevMax: string.Empty,
+                         dwnBin1Max: string.Empty,
+                         dwnBin2Max: string.Empty,
+                         dwnBin3Max: string.Empty,
+                         dwnBin4Max: string.Empty,
+                         dwnBin5Max: string.Empty,
+                         dwnBin6Max: string.Empty,
+                         dwnBin7Max: string.Empty,
+                         dwnBin8Max: string.Empty,
+                         dwnAllMean: dwnTotalsMeanSegments[0],
+                         dwnLpdMean: dwnTotalsMeanSegments[1],
+                         dwnLpdNMean: dwnTotalsMeanSegments[2],
+                         dwnLpdESMean: dwnTotalsMeanSegments[3],
+                         dwnMicroScrMean: dwnTotalsMeanSegments[4],
+                         dwnScrMean: dwnTotalsMeanSegments[5],
+                         dwnSlipMean: dwnTotalsMeanSegments[6],
+                         dwnAreaCountMean: dwnTotalsMeanSegments[7],
+                         dwnAreaMean: dwnTotalsMeanSegments[8],
+                         dwnHazeAvgMean: string.Empty,
+                         dwnHazeMedianMean: string.Empty,
+                         dwnHazeStdDevMean: string.Empty,
+                         dwnBin1Mean: string.Empty,
+                         dwnBin2Mean: string.Empty,
+                         dwnBin3Mean: string.Empty,
+                         dwnBin4Mean: string.Empty,
+                         dwnBin5Mean: string.Empty,
+                         dwnBin6Mean: string.Empty,
+                         dwnBin7Mean: string.Empty,
+                         dwnBin8Mean: string.Empty,
+                         dwnAllStdDev: dwnTotalsStandardDevSegments[0],
+                         dwnLpdStdDev: dwnTotalsStandardDevSegments[1],
+                         dwnLpdNStdDev: dwnTotalsStandardDevSegments[2],
+                         dwnLpdESStdDev: dwnTotalsStandardDevSegments[3],
+                         dwnMicroScrStdDev: dwnTotalsStandardDevSegments[4],
+                         dwnScrStdDev: dwnTotalsStandardDevSegments[5],
+                         dwnSlipStdDev: dwnTotalsStandardDevSegments[6],
+                         dwnAreaCountStdDev: dwnTotalsStandardDevSegments[7],
+                         dwnAreaStdDev: dwnTotalsStandardDevSegments[8],
+                         dwnHazeAvgStdDev: string.Empty,
+                         dwnHazeMedianStdDev: string.Empty,
+                         dwnHazeStdDevStdDev: string.Empty,
+                         dwnBin1StdDev: string.Empty,
+                         dwnBin2StdDev: string.Empty,
+                         dwnBin3StdDev: string.Empty,
+                         dwnBin4StdDev: string.Empty,
+                         dwnBin5StdDev: string.Empty,
+                         dwnBin6StdDev: string.Empty,
+                         dwnBin7StdDev: string.Empty,
+                         dwnBin8StdDev: string.Empty,
+                         dnnAllMin: string.Empty,
+                         dnnLpdMin: string.Empty,
+                         dnnLpdNMin: string.Empty,
+                         dnnLpdESMin: string.Empty,
+                         dnnMicroScrMin: string.Empty,
+                         dnnScrMin: string.Empty,
+                         dnnSlipMin: string.Empty,
+                         dnnAreaCountMin: string.Empty,
+                         dnnAreaMin: string.Empty,
+                         dnnHazeAvgMin: string.Empty,
+                         dnnHazeMedianMin: string.Empty,
+                         dnnHazeStdDevMin: string.Empty,
+                         dnnBin1Min: string.Empty,
+                         dnnBin2Min: string.Empty,
+                         dnnBin3Min: string.Empty,
+                         dnnBin4Min: string.Empty,
+                         dnnBin5Min: string.Empty,
+                         dnnBin6Min: string.Empty,
+                         dnnBin7Min: string.Empty,
+                         dnnBin8Min: string.Empty,
+                         dnnAllMax: string.Empty,
+                         dnnLpdMax: string.Empty,
+                         dnnLpdNMax: string.Empty,
+                         dnnLpdESMax: string.Empty,
+                         dnnMicroScrMax: string.Empty,
+                         dnnScrMax: string.Empty,
+                         dnnSlipMax: string.Empty,
+                         dnnAreaCountMax: string.Empty,
+                         dnnAreaMax: string.Empty,
+                         dnnHazeAvgMax: string.Empty,
+                         dnnHazeMedianMax: string.Empty,
+                         dnnHazeStdDevMax: string.Empty,
+                         dnnBin1Max: string.Empty,
+                         dnnBin2Max: string.Empty,
+                         dnnBin3Max: string.Empty,
+                         dnnBin4Max: string.Empty,
+                         dnnBin5Max: string.Empty,
+                         dnnBin6Max: string.Empty,
+                         dnnBin7Max: string.Empty,
+                         dnnBin8Max: string.Empty,
+                         dnnAllMean: string.Empty,
+                         dnnLpdMean: string.Empty,
+                         dnnLpdNMean: string.Empty,
+                         dnnLpdESMean: string.Empty,
+                         dnnMicroScrMean: string.Empty,
+                         dnnScrMean: string.Empty,
+                         dnnSlipMean: string.Empty,
+                         dnnAreaCountMean: string.Empty,
+                         dnnAreaMean: string.Empty,
+                         dnnHazeAvgMean: string.Empty,
+                         dnnHazeMedianMean: string.Empty,
+                         dnnHazeStdDevMean: string.Empty,
+                         dnnBin1Mean: string.Empty,
+                         dnnBin2Mean: string.Empty,
+                         dnnBin3Mean: string.Empty,
+                         dnnBin4Mean: string.Empty,
+                         dnnBin5Mean: string.Empty,
+                         dnnBin6Mean: string.Empty,
+                         dnnBin7Mean: string.Empty,
+                         dnnBin8Mean: string.Empty,
+                         dnnAllStdDev: string.Empty,
+                         dnnLpdStdDev: string.Empty,
+                         dnnLpdNStdDev: string.Empty,
+                         dnnLpdESStdDev: string.Empty,
+                         dnnMicroScrStdDev: string.Empty,
+                         dnnScrStdDev: string.Empty,
+                         dnnSlipStdDev: string.Empty,
+                         dnnAreaCountStdDev: string.Empty,
+                         dnnAreaStdDev: string.Empty,
+                         dnnHazeAvgStdDev: string.Empty,
+                         dnnHazeMedianStdDev: string.Empty,
+                         dnnHazeStdDevStdDev: string.Empty,
+                         dnnBin1StdDev: string.Empty,
+                         dnnBin2StdDev: string.Empty,
+                         dnnBin3StdDev: string.Empty,
+                         dnnBin4StdDev: string.Empty,
+                         dnnBin5StdDev: string.Empty,
+                         dnnBin6StdDev: string.Empty,
+                         dnnBin7StdDev: string.Empty,
+                         dnnBin8StdDev: string.Empty
+);
+        }
+        else if (text.Contains(constant.LongWaferSummary))
+        {
             result = new(dcnAllMin: dncTotalsMinSegments[0],
                          dcnLpdMin: dncTotalsMinSegments[1],
                          dcnLpdNMin: dncTotalsMinSegments[2],
@@ -1098,6 +1360,9 @@ public class Summary
                          dnnBin6StdDev: dnnTotalsStandardDevSegments[17],
                          dnnBin7StdDev: dnnTotalsStandardDevSegments[18],
                          dnnBin8StdDev: dnnTotalsStandardDevSegments[19]);
+        }
+        else
+            throw new Exception(constant.FormatExceptionMessage);
         return result;
     }
 

Adaptation/Shared/ProcessDataStandardFormat.cs

@@ -665,7 +665,7 @@ internal class ProcessDataStandardFormat
         return results;
     }
 
-    internal static string GetPDSFText(IFileRead fileRead, Logistics logistics, JsonElement[] jsonElements, string logisticsText)
+    internal static string GetPDSFText(IFileRead fileRead, Logistics logistics, JsonElement[] jsonElements, string? logisticsText)
     {
         string result;
         if (jsonElements.Length == 0)
@@ -850,33 +850,6 @@ internal class ProcessDataStandardFormat
             return string.Concat(((int)searchFor).ToString().PadLeft(2, '0'), separator, searchFor.ToString().Replace("In", string.Concat(separator, "In")).Replace("Ex", string.Concat(separator, "Ex")));
     }
 
-    private static int? TryGetPropertyIndex(JsonProperty[] jsonProperties, string propertyName)
-    {
-        int? result = null;
-        for (int i = 0; i < jsonProperties.Length; i++)
-        {
-            if (jsonProperties[i].Name != propertyName)
-                continue;
-            result = i;
-            break;
-        }
-        if (result is null)
-        {
-            for (int i = 0; i < jsonProperties.Length; i++)
-            {
-                if (jsonProperties[i].Name[0] != propertyName[0])
-                    continue;
-                if (jsonProperties[i].Name.Length != propertyName.Length)
-                    continue;
-                if (jsonProperties[i].Name != propertyName)
-                    continue;
-                result = i;
-                break;
-            }
-        }
-        return result;
-    }
-
     internal static string GetXml(ProcessDataStandardFormat processDataStandardFormat)
     {
         string result;

Adaptation/_Tests/CreateSelfDescription/Production/v2.61.1/TBI01.cs

@@ -0,0 +1,65 @@
+#if true
+using Adaptation._Tests.Shared;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+namespace Adaptation._Tests.CreateSelfDescription.Production.v2_61_1;
+
+[TestClass]
+public class TBI01 : EAFLoggingUnitTesting
+{
+
+#pragma warning disable CA2254
+#pragma warning disable IDE0060
+
+    internal static string DummyRoot { get; private set; }
+    internal static TBI01 EAFLoggingUnitTesting { get; private set; }
+
+    static TBI01() => DummyRoot = @"\\mesfs.infineon.com\EC_Characterization_Si\Dummy";
+
+    public TBI01() : base(DummyRoot, testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public TBI01(TestContext testContext) : base(DummyRoot, testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        EAFLoggingUnitTesting ??= new TBI01(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()
+    {
+        EAFLoggingUnitTesting?.Logger?.LogInformation("Cleanup");
+        EAFLoggingUnitTesting?.Dispose();
+    }
+
+#if DEBUG
+    [Ignore]
+#endif
+    [TestMethod]
+    public void Production__v2_61_1__TBI01__txt()
+    {
+        string check = "*.txt";
+        MethodBase methodBase = new StackFrame().GetMethod();
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Getting configuration"));
+        _ = AdaptationTesting.GetWriteConfigurationGetFileRead(methodBase, check, EAFLoggingUnitTesting.AdaptationTesting);
+        EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, " - Exit"));
+    }
+
+}
+#endif

Adaptation/_Tests/Extract/Production/v2.61.1/TBI01.cs

@@ -0,0 +1,58 @@
+#if true
+using Adaptation.Shared;
+using Adaptation.Shared.Methods;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Diagnostics;
+using System.Reflection;
+
+namespace Adaptation._Tests.Extract.Production.v2_61_1;
+
+[TestClass]
+public class TBI01
+{
+
+#pragma warning disable CA2254
+#pragma warning disable IDE0060
+
+    private static CreateSelfDescription.Production.v2_61_1.TBI01 _TBI01;
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        CreateSelfDescription.Production.v2_61_1.TBI01.ClassInitialize(testContext);
+        _TBI01 = CreateSelfDescription.Production.v2_61_1.TBI01.EAFLoggingUnitTesting;
+    }
+
+    private static void NonThrowTryCatch()
+    {
+        try
+        { throw new Exception(); }
+        catch (Exception) { }
+    }
+
+#if DEBUG
+    [Ignore]
+#endif
+    [TestMethod]
+    public void Production__v2_61_1__TBI01__txt() => _TBI01.Production__v2_61_1__TBI01__txt();
+
+#if DEBUG
+    [Ignore]
+#endif
+    [TestMethod]
+    public void Production__v2_61_1__TBI01__txt638997515742136250__Normal()
+    {
+        string check = "*.txt";
+        bool validatePDSF = false;
+        _TBI01.Production__v2_61_1__TBI01__txt();
+        MethodBase methodBase = new StackFrame().GetMethod();
+        string[] variables = _TBI01.AdaptationTesting.GetVariables(methodBase, check, validatePDSF);
+        IFileRead fileRead = _TBI01.AdaptationTesting.Get(methodBase, sourceFileLocation: variables[2], sourceFileFilter: variables[3], useCyclicalForDescription: false);
+        Logistics logistics = new(fileRead);
+        _ = Shared.AdaptationTesting.ReExtractCompareUpdatePassDirectory(variables, fileRead, logistics, validatePDSF);
+        NonThrowTryCatch();
+    }
+
+}
+#endif