EC - v2.43.0 - Jenkinsfile

Adaptation/_Tests/CreateSelfDescription/Staging/v2.43.0/EC.cs

@@ -0,0 +1,49 @@
+using Adaptation._Tests.Shared;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace Adaptation._Tests.CreateSelfDescription.Staging.v2_43_0;
+
+[TestClass]
+public class EC : EAFLoggingUnitTesting
+{
+
+#pragma warning disable CA2254
+#pragma warning disable IDE0060
+
+    internal static EC EAFLoggingUnitTesting { get; private set; }
+
+    public EC() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)
+    {
+        if (EAFLoggingUnitTesting is null)
+            throw new Exception();
+    }
+
+    public EC(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)
+    {
+    }
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        if (EAFLoggingUnitTesting is null)
+            EAFLoggingUnitTesting = new EC(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();
+    }
+
+}

Adaptation/_Tests/Extract/Staging/v2.43.0/EC.cs

@@ -0,0 +1,21 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Adaptation._Tests.Extract.Staging.v2_43_0;
+
+[TestClass]
+public class EC
+{
+
+#pragma warning disable CA2254
+#pragma warning disable IDE0060
+
+    private static CreateSelfDescription.Staging.v2_43_0.EC _EC;
+
+    [ClassInitialize]
+    public static void ClassInitialize(TestContext testContext)
+    {
+        CreateSelfDescription.Staging.v2_43_0.EC.ClassInitialize(testContext);
+        _EC = CreateSelfDescription.Staging.v2_43_0.EC.EAFLoggingUnitTesting;
+    }
+
+}

Adaptation/_Tests/Shared/EAFLoggingUnitTesting.cs

@@ -0,0 +1,28 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace Adaptation._Tests.Shared;
+
+public class EAFLoggingUnitTesting : LoggingUnitTesting, IDisposable
+{
+
+    protected readonly AdaptationTesting _AdaptationTesting;
+
+    public AdaptationTesting AdaptationTesting => _AdaptationTesting;
+
+    public EAFLoggingUnitTesting(TestContext testContext, Type declaringType, bool skipEquipmentDictionary) :
+        base(testContext, declaringType)
+    {
+        if (testContext is null || declaringType is null)
+            _AdaptationTesting = null;
+        else
+            _AdaptationTesting = new AdaptationTesting(testContext, skipEquipmentDictionary);
+    }
+
+    public new void Dispose()
+    {
+        base.Dispose();
+        GC.SuppressFinalize(this);
+    }
+
+}

Adaptation/_Tests/Shared/IsEnvironment.cs

@@ -0,0 +1,168 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Adaptation._Tests.Shared;
+
+public class IsEnvironment
+{
+
+    public enum Name
+    {
+        LinuxDevelopment,
+        LinuxProduction,
+        LinuxStaging,
+        OSXDevelopment,
+        OSXProduction,
+        OSXStaging,
+        WindowsDevelopment,
+        WindowsProduction,
+        WindowsStaging
+    }
+
+    public bool DebuggerWasAttachedDuringConstructor { get; private set; }
+    public bool Development { get; private set; }
+    public bool Linux { get; private set; }
+    public bool OSX { get; private set; }
+    public bool Production { get; private set; }
+    public bool Staging { get; private set; }
+    public bool Windows { get; private set; }
+    public string Profile { get; private set; }
+    public string AppSettingsFileName { get; private set; }
+    public string ASPNetCoreEnvironment { get; private set; }
+
+    public IsEnvironment(string testCategory)
+    {
+        if (testCategory.EndsWith(".json"))
+        {
+            Production = testCategory == "appsettings.json";
+            Staging = testCategory.EndsWith(nameof(Staging));
+            OSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+            Development = testCategory.EndsWith(nameof(Development));
+            Linux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+            DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+            Windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+            ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+        }
+        else
+        {
+            DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+            OSX = !string.IsNullOrEmpty(testCategory) && testCategory.StartsWith(nameof(OSX));
+            ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            Linux = !string.IsNullOrEmpty(testCategory) && testCategory.StartsWith(nameof(Linux));
+            Staging = !string.IsNullOrEmpty(testCategory) && testCategory.EndsWith(nameof(Staging));
+            Windows = !string.IsNullOrEmpty(testCategory) && testCategory.StartsWith(nameof(Windows));
+            Production = !string.IsNullOrEmpty(testCategory) && testCategory.EndsWith(nameof(Production));
+            Development = !string.IsNullOrEmpty(testCategory) && testCategory.EndsWith(nameof(Development));
+        }
+        Profile = GetProfile();
+        AppSettingsFileName = GetAppSettingsFileName(processesCount: null);
+    }
+
+    public IsEnvironment(bool isDevelopment, bool isStaging, bool isProduction)
+    {
+        Staging = isStaging;
+        Production = isProduction;
+        Development = isDevelopment;
+        OSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+        Linux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+        DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+        Windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+        ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+        Profile = GetProfile();
+        AppSettingsFileName = GetAppSettingsFileName(processesCount: null);
+    }
+
+    public IsEnvironment(int? processesCount, bool nullASPNetCoreEnvironmentIsDevelopment, bool nullASPNetCoreEnvironmentIsProduction)
+    {
+        OSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+        Linux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+        DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+        Windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+        ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+        if (nullASPNetCoreEnvironmentIsDevelopment && nullASPNetCoreEnvironmentIsProduction)
+            throw new Exception();
+        else if (string.IsNullOrEmpty(ASPNetCoreEnvironment) && nullASPNetCoreEnvironmentIsProduction)
+            Production = true;
+        else if (string.IsNullOrEmpty(ASPNetCoreEnvironment) && nullASPNetCoreEnvironmentIsDevelopment)
+            Development = true;
+        else if (string.IsNullOrEmpty(ASPNetCoreEnvironment) && !nullASPNetCoreEnvironmentIsDevelopment && !nullASPNetCoreEnvironmentIsProduction)
+            throw new Exception();
+        else
+        {
+            Staging = ASPNetCoreEnvironment is not null && ASPNetCoreEnvironment.EndsWith(nameof(Staging));
+            Production = ASPNetCoreEnvironment is not null && ASPNetCoreEnvironment.EndsWith(nameof(Production));
+            Development = ASPNetCoreEnvironment is not null && ASPNetCoreEnvironment.EndsWith(nameof(Development));
+        }
+        Profile = GetProfile();
+        AppSettingsFileName = GetAppSettingsFileName(processesCount);
+    }
+
+    private string GetProfile()
+    {
+        string result;
+        if (Windows && Production)
+            result = nameof(Production);
+        else if (Windows && Staging)
+            result = nameof(Staging);
+        else if (Windows && Development)
+            result = nameof(Development);
+        else if (Linux && Production)
+            result = nameof(Name.LinuxProduction);
+        else if (Linux && Staging)
+            result = nameof(Name.LinuxStaging);
+        else if (Linux && Development)
+            result = nameof(Name.LinuxDevelopment);
+        else if (OSX && Production)
+            result = nameof(Name.OSXProduction);
+        else if (OSX && Staging)
+            result = nameof(Name.OSXStaging);
+        else if (OSX && Development)
+            result = nameof(Name.OSXDevelopment);
+        else
+            throw new Exception();
+        return result;
+    }
+
+    private string GetAppSettingsFileName(int? processesCount)
+    {
+        string result;
+        if (Production)
+        {
+            if (processesCount is null)
+                result = "appsettings.json";
+            else
+                result = $"appsettings.{processesCount}.json";
+        }
+        else
+        {
+            string environment;
+            if (Staging)
+                environment = nameof(Staging);
+            else if (Development)
+                environment = nameof(Development);
+            else
+                throw new Exception();
+            if (processesCount is null)
+                result = $"appsettings.{environment}.json";
+            else
+                result = $"appsettings.{environment}.{processesCount}.json";
+        }
+        return result;
+    }
+
+    public static string GetEnvironmentName(IsEnvironment isEnvironment)
+    {
+        string result;
+        if (isEnvironment.Windows)
+            result = nameof(Windows);
+        else if (isEnvironment.Linux)
+            result = nameof(Linux);
+        else if (isEnvironment.OSX)
+            result = nameof(OSX);
+        else
+            throw new Exception();
+        return result;
+    }
+
+}

Adaptation/_Tests/Shared/Log/ConsoleLogger.cs

@@ -0,0 +1,36 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class ConsoleLogger : ILogger
+{
+
+    public int EventId { get; set; }
+
+    private readonly string _Name;
+    private readonly LogLevel _LogLevel;
+
+    public ConsoleLogger(LogLevel logLevel, string name)
+    {
+        _Name = name;
+        EventId = 0;
+        _LogLevel = logLevel;
+        if (string.IsNullOrEmpty(_Name))
+        { }
+    }
+
+    public IDisposable BeginScope<TState>(TState state) => null;
+
+    public bool IsEnabled(LogLevel logLevel) => logLevel >= _LogLevel;
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+    {
+        if (IsEnabled(logLevel) && (EventId == 0 || EventId == eventId.Id))
+        {
+            string message = formatter(state, null);
+            Console.WriteLine(message);
+        }
+    }
+
+}

Adaptation/_Tests/Shared/Log/ConsoleProvider.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Concurrent;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class ConsoleProvider : ILoggerProvider
+{
+
+    private readonly LogLevel _LogLevel;
+    private readonly ConcurrentDictionary<string, ConsoleLogger> _Loggers;
+
+    public ConsoleProvider(LogLevel logLevel)
+    {
+        _LogLevel = logLevel;
+        _Loggers = new ConcurrentDictionary<string, ConsoleLogger>();
+    }
+
+    public ILogger CreateLogger(string categoryName) => _Loggers.GetOrAdd(categoryName, name => new ConsoleLogger(_LogLevel, name));
+
+    public void Dispose()
+    {
+        _Loggers.Clear();
+        GC.SuppressFinalize(this);
+    }
+
+}

Adaptation/_Tests/Shared/Log/DebugLogger.cs

@@ -0,0 +1,36 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class DebugLogger : ILogger
+{
+
+    public int EventId { get; set; }
+
+    private readonly string _Name;
+    private readonly LogLevel _LogLevel;
+
+    public DebugLogger(LogLevel logLevel, string name)
+    {
+        _Name = name;
+        EventId = 0;
+        _LogLevel = logLevel;
+        if (string.IsNullOrEmpty(_Name))
+        { }
+    }
+
+    public IDisposable BeginScope<TState>(TState state) => null;
+
+    public bool IsEnabled(LogLevel logLevel) => logLevel >= _LogLevel;
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+    {
+        if (IsEnabled(logLevel) && (EventId == 0 || EventId == eventId.Id))
+        {
+            string message = formatter(state, null);
+            System.Diagnostics.Debug.Print(message);
+        }
+    }
+
+}

Adaptation/_Tests/Shared/Log/DebugProvider.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Concurrent;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class DebugProvider : ILoggerProvider
+{
+
+    private readonly LogLevel _LogLevel;
+    private readonly ConcurrentDictionary<string, DebugLogger> _Loggers;
+
+    public DebugProvider(LogLevel logLevel)
+    {
+        _LogLevel = logLevel;
+        _Loggers = new ConcurrentDictionary<string, DebugLogger>();
+    }
+
+    public ILogger CreateLogger(string categoryName) => _Loggers.GetOrAdd(categoryName, name => new DebugLogger(_LogLevel, name));
+
+    public void Dispose()
+    {
+        _Loggers.Clear();
+        GC.SuppressFinalize(this);
+    }
+
+}

Adaptation/_Tests/Shared/Log/FeedbackLogger.cs

@@ -0,0 +1,49 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class FeedbackLogger : ILogger
+{
+
+    public int EventId { get; set; }
+
+    private readonly string _Name;
+    private readonly LogLevel _LogLevel;
+    private readonly IFeedback _Feedback;
+
+    public FeedbackLogger(LogLevel logLevel, IFeedback feedback, string name)
+    {
+        _Feedback = feedback;
+        _Name = name;
+        EventId = 0;
+        _LogLevel = logLevel;
+        if (string.IsNullOrEmpty(_Name))
+        { }
+    }
+
+    public IDisposable BeginScope<TState>(TState state) => null;
+
+    public bool IsEnabled(LogLevel logLevel) => logLevel >= _LogLevel;
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+    {
+        if (IsEnabled(logLevel) && (EventId == 0 || EventId == eventId.Id))
+        {
+            string message = formatter(state, null);
+            int color = logLevel switch
+            {
+                LogLevel.Trace => -1,
+                LogLevel.Debug => -1,
+                LogLevel.Information => -16776961,
+                LogLevel.Warning => -65281,
+                LogLevel.Error => -65536,
+                LogLevel.Critical => -65536,
+                LogLevel.None => -1,
+                _ => throw new Exception(),
+            };
+            _Feedback.Print(message, color);
+        }
+    }
+
+}

Adaptation/_Tests/Shared/Log/FeedbackProvider.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Concurrent;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class FeedbackProvider : ILoggerProvider
+{
+
+    private readonly LogLevel _LogLevel;
+    private readonly IFeedback _Feedback;
+    private readonly ConcurrentDictionary<string, FeedbackLogger> _Loggers;
+
+    public FeedbackProvider(LogLevel logLevel, IFeedback feedback)
+    {
+        _LogLevel = logLevel;
+        _Feedback = feedback;
+        _Loggers = new ConcurrentDictionary<string, FeedbackLogger>();
+    }
+
+    public ILogger CreateLogger(string categoryName) => _Loggers.GetOrAdd(categoryName, name => new FeedbackLogger(_LogLevel, _Feedback, name));
+
+    public void Dispose()
+    {
+        _Loggers.Clear();
+        GC.SuppressFinalize(this);
+    }
+
+}

Adaptation/_Tests/Shared/Log/IFeedback.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public interface IFeedback
+{
+
+    List<string> Messages { get; }
+    void Print(string message, int color);
+
+}

Adaptation/_Tests/Shared/Log/Log.cs

@@ -0,0 +1,139 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Adaptation._Tests.Shared.Log;
+
+public class Log
+{
+
+#pragma warning disable CA2254
+#pragma warning disable IDE0060
+
+    private readonly ILogger _Logger;
+
+    public Log(ILogger logger) => _Logger = logger;
+
+    public void Black(object message) => _Logger.LogInformation(message.ToString());
+    public void Blue(object message) => _Logger.LogInformation(message.ToString());
+    public void Gray(object message) => _Logger.LogInformation(message.ToString());
+    public void Green(object message) => _Logger.LogInformation(message.ToString());
+    public void Magenta(string message, Exception exception) => _Logger.LogWarning(message, exception);
+    public void Red(string message, Exception exception) => _Logger.LogError(message, exception);
+    public void White(object message) => _Logger.LogInformation(message.ToString());
+    public void Yellow(string message, Exception exception) => _Logger.LogWarning(message, exception);
+
+    //
+
+    public void DoLog(LogLevel logLevel, EventId eventId, Exception exception, string message, params object[] args) => _Logger.Log(logLevel, eventId, exception, message, args);
+    public void DoLog(LogLevel logLevel, EventId eventId, string message, params object[] args) => _Logger.Log(logLevel, eventId, message, args);
+    public void DoLog(LogLevel logLevel, Exception exception, string message, params object[] args) => _Logger.Log(logLevel, exception, message, args);
+    public void DoLog(LogLevel logLevel, string message, params object[] args) => _Logger.Log(logLevel, message, args);
+    public void LogCritical(EventId eventId, Exception exception, string message, params object[] args) => _Logger.LogCritical(eventId, exception, message, args);
+    public void LogCritical(EventId eventId, string message, params object[] args) => _Logger.LogCritical(eventId, message, args);
+    public void LogCritical(Exception exception, string message, params object[] args) => _Logger.LogCritical(exception, message, args);
+    public void LogCritical(string message, params object[] args) => _Logger.LogCritical(message, args);
+    public void LogDebug(EventId eventId, Exception exception, string message, params object[] args) => _Logger.LogDebug(eventId, exception, message, args);
+    public void LogDebug(EventId eventId, string message, params object[] args) => _Logger.LogDebug(eventId, message, args);
+    public void LogDebug(Exception exception, string message, params object[] args) => _Logger.LogDebug(exception, message, args);
+    public void LogDebug(string message, params object[] args) => _Logger.LogDebug(message, args);
+    public void LogError(EventId eventId, Exception exception, string message, params object[] args) => _Logger.LogError(eventId, exception, message, args);
+    public void LogError(EventId eventId, string message, params object[] args) => _Logger.LogError(eventId, message, args);
+    public void LogError(Exception exception, string message, params object[] args) => _Logger.LogError(message, args);
+    public void LogError(string message, params object[] args) => _Logger.LogError(message, args);
+    public void LogInformation(EventId eventId, Exception exception, string message, params object[] args) => _Logger.LogInformation(eventId, exception, message, args);
+    public void LogInformation(EventId eventId, string message, params object[] args) => _Logger.LogInformation(eventId, message, args);
+    public void LogInformation(Exception exception, string message, params object[] args) => _Logger.LogInformation(exception, message, args);
+    public void LogInformation(string message, params object[] args) => _Logger.LogInformation(message, args);
+    public void LogTrace(EventId eventId, Exception exception, string message, params object[] args) => _Logger.LogTrace(eventId, exception, message, args);
+    public void LogTrace(EventId eventId, string message, params object[] args) => _Logger.LogTrace(eventId, message, args);
+    public void LogTrace(Exception exception, string message, params object[] args) => _Logger.LogTrace(exception, message, args);
+    public void LogTrace(string message, params object[] args) => _Logger.LogTrace(message, args);
+    public void LogWarning(EventId eventId, Exception exception, string message, params object[] args) => _Logger.LogWarning(eventId, exception, message, args);
+    public void LogWarning(EventId eventId, string message, params object[] args) => _Logger.LogWarning(eventId, message, args);
+    public void LogWarning(Exception exception, string message, params object[] args) => _Logger.LogWarning(exception, message, args);
+    public void LogWarning(string message, params object[] args) => _Logger.LogWarning(message, args);
+
+    //
+
+    public void Debug() => _Logger.LogDebug(string.Empty);
+    public void Debug(object message) => _Logger.LogDebug(message.ToString());
+    public void Debug(string message, Exception exception) => _Logger.LogDebug(exception, message);
+    public void DebugFormat(IFormatProvider provider, string format, params object[] args) => _Logger.LogDebug(string.Format(provider, format, args));
+    public void DebugFormat(string format, object arg0, object arg1, object arg2) => _Logger.LogDebug(string.Format(format, arg0, arg1, arg2));
+    public void DebugFormat(string format, object arg0, object arg1) => _Logger.LogDebug(string.Format(format, arg0, arg1));
+    public void DebugFormat(string format, object arg0) => _Logger.LogDebug(string.Format(format, arg0));
+    public void DebugFormat(string format, params object[] args) => _Logger.LogDebug(string.Format(format, args));
+    public void Error(object message) => _Logger.LogError(message.ToString());
+    public void Error(string message, Exception exception) => _Logger.LogError(exception, message.ToString());
+    public void ErrorFormat(IFormatProvider provider, string format, params object[] args) => _Logger.LogError(string.Format(provider, format, args));
+    public void ErrorFormat(string format, object arg0, object arg1, object arg2) => _Logger.LogError(string.Format(format, arg0, arg1, arg2));
+    public void ErrorFormat(string format, object arg0, object arg1) => _Logger.LogError(string.Format(format, arg0, arg1));
+    public void ErrorFormat(string format, object arg0) => _Logger.LogError(string.Format(format, arg0));
+    public void ErrorFormat(string format, params object[] args) => _Logger.LogError(string.Format(format, args));
+    public void Fatal(object message) => _Logger.LogCritical(message.ToString());
+    public void Fatal(string message, Exception exception) => _Logger.LogCritical(exception, message.ToString());
+    public void FatalFormat(IFormatProvider provider, string format, params object[] args) => _Logger.LogCritical(string.Format(provider, format, args));
+    public void FatalFormat(string format, object arg0, object arg1, object arg2) => _Logger.LogCritical(string.Format(format, arg0, arg1, arg2));
+    public void FatalFormat(string format, object arg0, object arg1) => _Logger.LogCritical(string.Format(format, arg0, arg1));
+    public void FatalFormat(string format, object arg0) => _Logger.LogCritical(string.Format(format, arg0));
+    public void FatalFormat(string format, params object[] args) => _Logger.LogCritical(string.Format(format, args));
+    public void Info(object message) => _Logger.LogInformation(message.ToString());
+    public void Info(string message, Exception exception) => _Logger.LogInformation(exception, message.ToString());
+    public void InfoFormat(IFormatProvider provider, string format, params object[] args) => _Logger.LogInformation(string.Format(provider, format, args));
+    public void InfoFormat(string format, object arg0, object arg1, object arg2) => _Logger.LogInformation(string.Format(format, arg0, arg1, arg2));
+    public void InfoFormat(string format, object arg0, object arg1) => _Logger.LogInformation(string.Format(format, arg0, arg1));
+    public void InfoFormat(string format, object arg0) => _Logger.LogInformation(string.Format(format, arg0));
+    public void InfoFormat(string format, params object[] args) => _Logger.LogInformation(string.Format(format, args));
+    public void Warn(object message) => _Logger.LogWarning(message.ToString());
+    public void Warn(string message, Exception exception) => _Logger.LogWarning(exception, message.ToString());
+    public void WarnFormat(IFormatProvider provider, string format, params object[] args) => _Logger.LogWarning(string.Format(provider, format, args));
+    public void WarnFormat(string format, object arg0, object arg1, object arg2) => _Logger.LogWarning(string.Format(format, arg0, arg1, arg2));
+    public void WarnFormat(string format, object arg0, object arg1) => _Logger.LogWarning(string.Format(format, arg0, arg1));
+    public void WarnFormat(string format, object arg0) => _Logger.LogWarning(string.Format(format, arg0));
+    public void WarnFormat(string format, params object[] args) => _Logger.LogWarning(string.Format(format, args));
+
+    public static string GetWorkingDirectory(string executingAssemblyName, string subDirectoryName)
+    {
+        string result = string.Empty;
+        string traceFile;
+        List<string> directories = new();
+        Environment.SpecialFolder[] specialFolders = new Environment.SpecialFolder[]
+        {
+                    Environment.SpecialFolder.LocalApplicationData,
+                    Environment.SpecialFolder.ApplicationData,
+                    Environment.SpecialFolder.History,
+                    Environment.SpecialFolder.CommonApplicationData,
+                    Environment.SpecialFolder.InternetCache
+        };
+        foreach (Environment.SpecialFolder specialFolder in specialFolders)
+            directories.Add(Path.Combine(Environment.GetFolderPath(specialFolder), subDirectoryName, executingAssemblyName));
+        foreach (string directory in directories)
+        {
+            for (int i = 1; i < 3; i++)
+            {
+                if (i == 1)
+                    result = directory;
+                else
+                    result = string.Concat("D", directory[1..]);
+                try
+                {
+                    if (!Directory.Exists(result))
+                        _ = Directory.CreateDirectory(result);
+                    traceFile = string.Concat(result, @"\", DateTime.Now.Ticks, ".txt");
+                    File.WriteAllText(traceFile, traceFile);
+                    File.Delete(traceFile);
+                    break;
+                }
+                catch (Exception) { result = string.Empty; }
+            }
+            if (!string.IsNullOrEmpty(result))
+                break;
+        }
+        if (string.IsNullOrEmpty(result))
+            throw new Exception("Unable to set working directory!");
+        return result;
+    }
+
+}

Adaptation/_Tests/Shared/LoggingUnitTesting.cs

@@ -0,0 +1,112 @@
+using Adaptation._Tests.Shared.Log;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Adaptation._Tests.Shared;
+
+public class LoggingUnitTesting : UnitTesting, IDisposable
+{
+
+    protected ILogger<object> _Logger;
+    protected ILoggerFactory _LoggerFactory;
+    protected readonly LogLevel? _DefaultLogLevel;
+    protected readonly LogLevel? _Log4netProviderLogLevel;
+    protected readonly IConfigurationRoot _ConfigurationRoot;
+    public ILogger<object> Logger => _Logger;
+    public LogLevel? DefaultLogLevel => _DefaultLogLevel;
+    public ILoggerFactory LoggerFactory => _LoggerFactory;
+    public IConfigurationRoot ConfigurationRoot => _ConfigurationRoot;
+    public LogLevel? Log4netProviderLogLevel => _Log4netProviderLogLevel;
+
+    public LoggingUnitTesting(TestContext testContext, Type declaringType) :
+        base(testContext, declaringType)
+    {
+        _LoggerFactory = new LoggerFactory();
+        if (testContext is null || declaringType is null)
+        {
+            _ConfigurationRoot = null;
+            _DefaultLogLevel = null;
+            _Log4netProviderLogLevel = null;
+        }
+        else
+        {
+            LogLevel logLevel;
+            IConfigurationSection configurationSection;
+            List<LogLevel> logLevels = new();
+            string defaultLogLevelSection = "Logging:LogLevel:Default";
+            string log4netProviderLogLevelSection = "Logging:LogLevel:Log4netProvider";
+            string[] sections = new string[] { defaultLogLevelSection, log4netProviderLogLevelSection };
+            IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
+                .AddEnvironmentVariables()
+                .AddJsonFile(_IsEnvironment.AppSettingsFileName, optional: false, reloadOnChange: true);
+            _ConfigurationRoot = configurationBuilder.Build();
+            foreach (string section in sections)
+            {
+                configurationSection = _ConfigurationRoot.GetSection(section);
+                if (configurationSection is null)
+                    logLevel = LogLevel.Debug;
+                else if (!Enum.TryParse(configurationSection.Value, out logLevel))
+                    logLevel = LogLevel.Debug;
+                logLevels.Add(logLevel);
+            }
+            _DefaultLogLevel = logLevels[0];
+            _Log4netProviderLogLevel = logLevels[1];
+        }
+        if (DefaultLogLevel.HasValue)
+            _LoggerFactory.AddProvider(new DebugProvider(DefaultLogLevel.Value));
+        if (DefaultLogLevel.HasValue)
+            _LoggerFactory.AddProvider(new ConsoleProvider(DefaultLogLevel.Value));
+        _Logger = _LoggerFactory.CreateLogger<object>();
+    }
+
+    public static string GetEnvironmentSpecialDirectory()
+    {
+        string result = string.Empty;
+        string traceFile;
+        List<string> directories = new();
+        Environment.SpecialFolder[] specialFolders = new Environment.SpecialFolder[]
+        {
+                    Environment.SpecialFolder.LocalApplicationData,
+                    Environment.SpecialFolder.ApplicationData,
+                    Environment.SpecialFolder.History,
+                    Environment.SpecialFolder.CommonApplicationData,
+                    Environment.SpecialFolder.InternetCache
+        };
+        foreach (Environment.SpecialFolder specialFolder in specialFolders)
+            directories.Add(Environment.GetFolderPath(specialFolder));
+        foreach (string directory in directories)
+        {
+            for (int i = 1; i < 3; i++)
+            {
+                if (i == 1)
+                    result = directory;
+                else
+                    result = string.Concat("D", directory.Substring(1));
+                try
+                {
+                    if (!Directory.Exists(result))
+                        _ = Directory.CreateDirectory(result);
+                    traceFile = string.Concat(result, @"\", DateTime.Now.Ticks, ".txt");
+                    File.WriteAllText(traceFile, traceFile);
+                    File.Delete(traceFile);
+                    break;
+                }
+                catch (Exception) { result = string.Empty; }
+            }
+            if (!string.IsNullOrEmpty(result))
+                break;
+        }
+        return result;
+    }
+
+    public void Dispose()
+    {
+        _LoggerFactory.Dispose();
+        GC.SuppressFinalize(this);
+    }
+
+}

Adaptation/_Tests/Shared/PasteSpecialXml/EAF XML API/ConfigurationData.cs

@@ -0,0 +1,23 @@
+using System.Xml.Serialization;
+
+namespace Adaptation._Tests.Shared.PasteSpecialXml.EAF.XML.API.ConfigurationData;
+
+[XmlRoot(ElementName = "ChildBackboneMembers", Namespace = "http://schemas.datacontract.org/2004/07/EafManagement.Configuration.Services")]
+public class ChildBackboneMembers
+{
+    [XmlAttribute(AttributeName = "nil", Namespace = "http://www.w3.org/2001/XMLSchema-instance")]
+    public string Nil { get; set; }
+}
+
+[XmlRoot(ElementName = "ConfigurationData", Namespace = "http://schemas.datacontract.org/2004/07/EafManagement.Configuration.Services")]
+public class ConfigurationData
+{
+    [XmlElement(ElementName = "ChildBackboneMembers", Namespace = "http://schemas.datacontract.org/2004/07/EafManagement.Configuration.Services")]
+    public ChildBackboneMembers ChildBackboneMembers { get; set; }
+    [XmlElement(ElementName = "Data", Namespace = "http://schemas.datacontract.org/2004/07/EafManagement.Configuration.Services")]
+    public string Data { get; set; }
+    [XmlAttribute(AttributeName = "xmlns")]
+    public string Xmlns { get; set; }
+    [XmlAttribute(AttributeName = "i", Namespace = "http://www.w3.org/2000/xmlns/")]
+    public string I { get; set; }
+}

Adaptation/_Tests/Shared/PasteSpecialXml/EAF XML API/EquipmentType.cs

@@ -0,0 +1,964 @@
+using System;
+
+namespace Adaptation._Tests.Shared.PasteSpecialXml.EAF.XML.API.EquipmentType;
+
+// NOTE: Generated code may require at least .NET Framework 4.5 or .NET Core/Standard 2.0.
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.FactoryEntities")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.FactoryEntities", IsNullable = false)]
+public partial class EquipmentTypeVersion
+{
+
+#pragma warning disable IDE1006 // Naming Styles
+
+    private string createdByField;
+
+    private DateTime creationDateField;
+
+    private object descriptionField;
+
+    private ExtensionsVersionExtension[] extensionsField;
+
+    private DateTime freezeDateField;
+
+    private string frozenByField;
+
+    private byte idField;
+
+    private bool isFrozenField;
+
+    private bool isRetiredField;
+
+    private DateTime retireDateField;
+
+    private object retiredByField;
+
+    private SelectedDeploymentPackage[] deploymentPackagesField;
+
+    private EquipmentTypeVersionDictionaries dictionariesField;
+
+    private string nameField;
+
+    private EquipmentTypeVersionParentType parentTypeField;
+
+    private ParameterizedModelObjectDefinition[] equipmentComponentsField;
+
+    private EventActionSequenceDefinition[] eventActionSequencesField;
+
+    private object fileCommunicatorObjectTypesField;
+
+    private FileConfiguration fileConfigurationField;
+
+    private FileHandlerObjectTypes fileHandlerObjectTypesField;
+
+    private ParameterizedModelObjectDefinition[] transientEquipmentObjectTypesField;
+
+    private string id1Field;
+
+    private string i___typeField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public string CreatedBy
+    {
+        get => this.createdByField;
+        set => this.createdByField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public DateTime CreationDate
+    {
+        get => this.creationDateField;
+        set => this.creationDateField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities", IsNullable = true)]
+    public object Description
+    {
+        get => this.descriptionField;
+        set => this.descriptionField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArray(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    [System.Xml.Serialization.XmlArrayItem("VersionExtension", IsNullable = false)]
+    public ExtensionsVersionExtension[] Extensions
+    {
+        get => this.extensionsField;
+        set => this.extensionsField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public DateTime FreezeDate
+    {
+        get => this.freezeDateField;
+        set => this.freezeDateField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public string FrozenBy
+    {
+        get => this.frozenByField;
+        set => this.frozenByField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public bool IsFrozen
+    {
+        get => this.isFrozenField;
+        set => this.isFrozenField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public bool IsRetired
+    {
+        get => this.isRetiredField;
+        set => this.isRetiredField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities")]
+    public DateTime RetireDate
+    {
+        get => this.retireDateField;
+        set => this.retireDateField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+        "ntities", IsNullable = true)]
+    public object RetiredBy
+    {
+        get => this.retiredByField;
+        set => this.retiredByField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArrayItem("SelectedDeploymentPackage", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.Deployme" +
+        "nt", IsNullable = false)]
+    public SelectedDeploymentPackage[] DeploymentPackages
+    {
+        get => this.deploymentPackagesField;
+        set => this.deploymentPackagesField = value;
+    }
+
+    /// <remarks/>
+    public EquipmentTypeVersionDictionaries Dictionaries
+    {
+        get => this.dictionariesField;
+        set => this.dictionariesField = value;
+    }
+
+    /// <remarks/>
+    public string Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    public EquipmentTypeVersionParentType ParentType
+    {
+        get => this.parentTypeField;
+        set => this.parentTypeField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArray(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+        "Connector.EquipmentTypes")]
+    [System.Xml.Serialization.XmlArrayItem("ParameterizedModelObjectDefinition", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation", IsNullable = false)]
+    public ParameterizedModelObjectDefinition[] EquipmentComponents
+    {
+        get => this.equipmentComponentsField;
+        set => this.equipmentComponentsField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArray(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+        "Connector.EquipmentTypes")]
+    [System.Xml.Serialization.XmlArrayItem("EventActionSequenceDefinition", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation", IsNullable = false)]
+    public EventActionSequenceDefinition[] EventActionSequences
+    {
+        get => this.eventActionSequencesField;
+        set => this.eventActionSequencesField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+        "Connector.EquipmentTypes")]
+    public object FileCommunicatorObjectTypes
+    {
+        get => this.fileCommunicatorObjectTypesField;
+        set => this.fileCommunicatorObjectTypesField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+        "Connector.EquipmentTypes")]
+    public FileConfiguration FileConfiguration
+    {
+        get => this.fileConfigurationField;
+        set => this.fileConfigurationField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+        "Connector.EquipmentTypes")]
+    public FileHandlerObjectTypes FileHandlerObjectTypes
+    {
+        get => this.fileHandlerObjectTypesField;
+        set => this.fileHandlerObjectTypesField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArray(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+        "Connector.EquipmentTypes")]
+    [System.Xml.Serialization.XmlArrayItem("ParameterizedModelObjectDefinition", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation", IsNullable = false)]
+    public ParameterizedModelObjectDefinition[] TransientEquipmentObjectTypes
+    {
+        get => this.transientEquipmentObjectTypesField;
+        set => this.transientEquipmentObjectTypesField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute()]
+    public string i___type
+    {
+        get => this.i___typeField;
+        set => this.i___typeField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.Deployme" +
+    "nt")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.Deployme" +
+    "nt", IsNullable = false)]
+public partial class SelectedDeploymentPackage
+{
+
+    private byte idField;
+
+    private string packageNameField;
+
+    private string packageVersionField;
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    public string PackageName
+    {
+        get => this.packageNameField;
+        set => this.packageNameField = value;
+    }
+
+    /// <remarks/>
+    public string PackageVersion
+    {
+        get => this.packageVersionField;
+        set => this.packageVersionField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+    "ntities")]
+public partial class ExtensionsVersionExtension
+{
+
+    private byte idField;
+
+    private string classNameField;
+
+    private object configurationField;
+
+    private string nameField;
+
+    private string id1Field;
+
+    private string i___typeField;
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.Backbone" +
+        "s")]
+    public string ClassName
+    {
+        get => this.classNameField;
+        set => this.classNameField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.Backbone" +
+        "s", IsNullable = true)]
+    public object Configuration
+    {
+        get => this.configurationField;
+        set => this.configurationField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.Backbone" +
+        "s")]
+    public string Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute()]
+    public string i___type
+    {
+        get => this.i___typeField;
+        set => this.i___typeField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.FactoryEntities")]
+public partial class EquipmentTypeVersionDictionaries
+{
+
+    private EquipmentTypeVersionDictionariesEquipmentTypeDictionaryReference equipmentTypeDictionaryReferenceField;
+
+    /// <remarks/>
+    public EquipmentTypeVersionDictionariesEquipmentTypeDictionaryReference EquipmentTypeDictionaryReference
+    {
+        get => this.equipmentTypeDictionaryReferenceField;
+        set => this.equipmentTypeDictionaryReferenceField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.FactoryEntities")]
+public partial class EquipmentTypeVersionDictionariesEquipmentTypeDictionaryReference
+{
+
+    private string dictionaryNameField;
+
+    private string dictionaryVersionField;
+
+    private byte idField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    public string DictionaryName
+    {
+        get => this.dictionaryNameField;
+        set => this.dictionaryNameField = value;
+    }
+
+    /// <remarks/>
+    public string DictionaryVersion
+    {
+        get => this.dictionaryVersionField;
+        set => this.dictionaryVersionField = value;
+    }
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.FactoryEntities")]
+public partial class EquipmentTypeVersionParentType
+{
+
+    private byte idField;
+
+    private string nameField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    public string Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation", IsNullable = false)]
+public partial class ParameterizedModelObjectDefinition
+{
+
+    private byte idField;
+
+    private string nameField;
+
+    private ParameterizedModelObjectDefinitionModelObjectParameterDefinition[] parametersField;
+
+    private string typeField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    public string Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArrayItem("ModelObjectParameterDefinition", IsNullable = false)]
+    public ParameterizedModelObjectDefinitionModelObjectParameterDefinition[] Parameters
+    {
+        get => this.parametersField;
+        set => this.parametersField = value;
+    }
+
+    /// <remarks/>
+    public string Type
+    {
+        get => this.typeField;
+        set => this.typeField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation")]
+public partial class ParameterizedModelObjectDefinitionModelObjectParameterDefinition
+{
+
+    private string enumTypeField;
+
+    private byte idField;
+
+    private string nameField;
+
+    private string valueField;
+
+    private string valueTypeField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(IsNullable = true)]
+    public string EnumType
+    {
+        get => this.enumTypeField;
+        set => this.enumTypeField = value;
+    }
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    public string Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    public string Value
+    {
+        get => this.valueField;
+        set => this.valueField = value;
+    }
+
+    /// <remarks/>
+    public string ValueType
+    {
+        get => this.valueTypeField;
+        set => this.valueTypeField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation", IsNullable = false)]
+public partial class EventActionSequenceDefinition
+{
+
+    private EventActionSequenceDefinitionEventActionParameterDefinition[] actionsField;
+
+    private string eventTypeField;
+
+    private string handledEventField;
+
+    private byte idField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArrayItem("EventActionParameterDefinition", IsNullable = false)]
+    public EventActionSequenceDefinitionEventActionParameterDefinition[] Actions
+    {
+        get => this.actionsField;
+        set => this.actionsField = value;
+    }
+
+    /// <remarks/>
+    public string EventType
+    {
+        get => this.eventTypeField;
+        set => this.eventTypeField = value;
+    }
+
+    /// <remarks/>
+    public string HandledEvent
+    {
+        get => this.handledEventField;
+        set => this.handledEventField = value;
+    }
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes", IsNullable = false)]
+public class FileConfiguration
+{
+
+    private string idField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes", IsNullable = false)]
+public class FileHandlerObjectTypes
+{
+
+    private ParameterizedModelObjectDefinition parameterizedModelObjectDefinitionField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation")]
+    public ParameterizedModelObjectDefinition ParameterizedModelObjectDefinition
+    {
+        get => this.parameterizedModelObjectDefinitionField;
+        set => this.parameterizedModelObjectDefinitionField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+    "ntities")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.FactoryE" +
+    "ntities", IsNullable = false)]
+public partial class Extensions
+{
+
+    private ExtensionsVersionExtension[] versionExtensionField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement("VersionExtension")]
+    public ExtensionsVersionExtension[] VersionExtension
+    {
+        get => this.versionExtensionField;
+        set => this.versionExtensionField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes", IsNullable = false)]
+public partial class EquipmentComponents
+{
+
+    private ParameterizedModelObjectDefinition[] parameterizedModelObjectDefinitionField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement("ParameterizedModelObjectDefinition", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation")]
+    public ParameterizedModelObjectDefinition[] ParameterizedModelObjectDefinition
+    {
+        get => this.parameterizedModelObjectDefinitionField;
+        set => this.parameterizedModelObjectDefinitionField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes", IsNullable = false)]
+public partial class EventActionSequences
+{
+
+    private EventActionSequenceDefinition[] eventActionSequenceDefinitionField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement("EventActionSequenceDefinition", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation")]
+    public EventActionSequenceDefinition[] EventActionSequenceDefinition
+    {
+        get => this.eventActionSequenceDefinitionField;
+        set => this.eventActionSequenceDefinitionField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes")]
+[System.Xml.Serialization.XmlRoot(Namespace = "http://schemas.datacontract.org/2004/07/EafRuntimeIfx.ManagementInterfaceIfx.File" +
+    "Connector.EquipmentTypes", IsNullable = false)]
+public partial class TransientEquipmentObjectTypes
+{
+
+    private ParameterizedModelObjectDefinition[] parameterizedModelObjectDefinitionField;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement("ParameterizedModelObjectDefinition", Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+        "mation")]
+    public ParameterizedModelObjectDefinition[] ParameterizedModelObjectDefinition
+    {
+        get => this.parameterizedModelObjectDefinitionField;
+        set => this.parameterizedModelObjectDefinitionField = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation")]
+public partial class EventActionSequenceDefinitionEventActionParameterDefinition
+{
+
+    private byte idField;
+
+    private object nameField;
+
+    private EventActionSequenceDefinitionEventActionParameterDefinitionModelObjectParameterDefinition[] parametersField;
+
+    private string typeField;
+
+    private byte positionField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(IsNullable = true)]
+    public object Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlArrayItem("ModelObjectParameterDefinition", IsNullable = false)]
+    public EventActionSequenceDefinitionEventActionParameterDefinitionModelObjectParameterDefinition[] Parameters
+    {
+        get => this.parametersField;
+        set => this.parametersField = value;
+    }
+
+    /// <remarks/>
+    public string Type
+    {
+        get => this.typeField;
+        set => this.typeField = value;
+    }
+
+    /// <remarks/>
+    public byte Position
+    {
+        get => this.positionField;
+        set => this.positionField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}
+
+/// <remarks/>
+[Serializable()]
+[System.ComponentModel.DesignerCategory("code")]
+[System.Xml.Serialization.XmlType(AnonymousType = true, Namespace = "http://schemas.datacontract.org/2004/07/Eaf.Management.ConfigurationData.CellAuto" +
+    "mation")]
+public partial class EventActionSequenceDefinitionEventActionParameterDefinitionModelObjectParameterDefinition
+{
+
+    private object categoryField;
+
+    private object descriptionField;
+
+    private object displayNameField;
+
+    private object enumTypeField;
+
+    private byte idField;
+
+    private bool isMandatoryField;
+
+    private string nameField;
+
+    private byte orderField;
+
+    private string valueField;
+
+    private string valueTypeField;
+
+    private string id1Field;
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(IsNullable = true)]
+    public object Category
+    {
+        get => this.categoryField;
+        set => this.categoryField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(IsNullable = true)]
+    public object Description
+    {
+        get => this.descriptionField;
+        set => this.descriptionField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(IsNullable = true)]
+    public object DisplayName
+    {
+        get => this.displayNameField;
+        set => this.displayNameField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlElement(IsNullable = true)]
+    public object EnumType
+    {
+        get => this.enumTypeField;
+        set => this.enumTypeField = value;
+    }
+
+    /// <remarks/>
+    public byte Id
+    {
+        get => this.idField;
+        set => this.idField = value;
+    }
+
+    /// <remarks/>
+    public bool IsMandatory
+    {
+        get => this.isMandatoryField;
+        set => this.isMandatoryField = value;
+    }
+
+    /// <remarks/>
+    public string Name
+    {
+        get => this.nameField;
+        set => this.nameField = value;
+    }
+
+    /// <remarks/>
+    public byte Order
+    {
+        get => this.orderField;
+        set => this.orderField = value;
+    }
+
+    /// <remarks/>
+    public string Value
+    {
+        get => this.valueField;
+        set => this.valueField = value;
+    }
+
+    /// <remarks/>
+    public string ValueType
+    {
+        get => this.valueTypeField;
+        set => this.valueTypeField = value;
+    }
+
+    /// <remarks/>
+    [System.Xml.Serialization.XmlAttribute("Id", Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.microsoft.com/2003/10/Serialization/")]
+    public string Id1
+    {
+        get => this.id1Field;
+        set => this.id1Field = value;
+    }
+}

Adaptation/_Tests/Shared/UnitTesting.cs

@@ -0,0 +1,90 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+
+namespace Adaptation._Tests.Shared;
+
+public class UnitTesting
+{
+
+    protected readonly IsEnvironment _IsEnvironment;
+
+    public IsEnvironment IsEnvironment => _IsEnvironment;
+
+    public UnitTesting(TestContext testContext, Type declaringType)
+    {
+        if (testContext is null || declaringType is null)
+            _IsEnvironment = null;
+        else
+        {
+            string projectDirectory = GetProjectDirectory(testContext);
+            string json = JsonSerializer.Serialize(testContext.Properties);
+            string vsCodeDirectory = Path.Combine(projectDirectory, ".vscode");
+            if (!Directory.Exists(vsCodeDirectory))
+                _ = Directory.CreateDirectory(vsCodeDirectory);
+            string launchText = GetLaunchText();
+            File.WriteAllText(Path.Combine(vsCodeDirectory, "launch.json"), launchText);
+            for (int i = 0; i < int.MaxValue; i++)
+            {
+                if (!json.Contains("Debugger.IsAttached") || Debugger.IsAttached)
+                    break;
+                Thread.Sleep(500);
+            }
+            MethodBase methodBase = declaringType.GetMethod(testContext.TestName);
+            if (methodBase is not null)
+            {
+                TestCategoryAttribute testCategoryAttribute = methodBase.GetCustomAttribute<TestCategoryAttribute>();
+                if (testCategoryAttribute is not null)
+                {
+                    foreach (string testCategory in testCategoryAttribute.TestCategories)
+                        _IsEnvironment = new IsEnvironment(testCategory);
+                }
+            }
+            if (_IsEnvironment is null)
+                _IsEnvironment = new IsEnvironment(processesCount: null, nullASPNetCoreEnvironmentIsDevelopment: Debugger.IsAttached, nullASPNetCoreEnvironmentIsProduction: !Debugger.IsAttached);
+        }
+    }
+
+    internal static string GetProjectDirectory(TestContext testContext)
+    {
+        string result;
+        string[] checkFiles = null;
+        result = Path.GetDirectoryName(testContext.DeploymentDirectory);
+        for (int i = 0; i < int.MaxValue; i++)
+        {
+            if (string.IsNullOrEmpty(result))
+                break;
+            checkFiles = Directory.GetFiles(result, "*.Tests.*proj", SearchOption.TopDirectoryOnly);
+            if (checkFiles.Any())
+                break;
+            result = Path.GetDirectoryName(result);
+        }
+        if (string.IsNullOrEmpty(result) || checkFiles is null || !checkFiles.Any())
+            throw new Exception(result);
+        return result;
+    }
+
+    internal static string GetLaunchText()
+    {
+        StringBuilder result = new();
+        _ = result.
+            AppendLine("{").
+            AppendLine("  \"configurations\": [").
+            AppendLine("    {").
+            AppendLine("      \"name\": \".NET Core Attach\",").
+            AppendLine("      \"type\": \"coreclr\",").
+            AppendLine("      \"request\": \"attach\",").
+            AppendLine($"      \"processId\": {Environment.ProcessId}").
+            AppendLine("    }").
+            AppendLine("  ]").
+            AppendLine("}");
+        return result.ToString();
+    }
+
+}