public OfficeApplicationObjectProvider(object officeApplicationObject, ApplicationType applicationType)
 {
     // TODO: Complete member initialization
     this.officeApplicationObject = officeApplicationObject;
     m_bExternalApplication = officeApplicationObject != null;
     this.applicationType = applicationType;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        public SemanticConstraintRegistry(FileFormatVersions format, ApplicationType appType)
        {
            _format = format;
            _appType = appType;

            Initialize();
        }

 internal Element(BaseStorage storage, Guid obj, ApplicationType appType, int identifier)
 {
     _storage = storage;
     _obj = obj;
     _appType = appType;
     _identifier = identifier;
 }

        public SemanticValidator(FileFormatVersions format, ApplicationType app)
        {
            FileFormat = format;
            AppType = app;

            _curReg = new SemanticConstraintRegistry(format, app);
        }

        internal static MonoProcess Start(ApplicationType type, string _targetExe)
        {
            if (type == ApplicationType.Desktopapplication)
                return new MonoDesktopProcess(_targetExe);
            if (type == ApplicationType.Webapplication)
                return new MonoWebProcess();

            throw new Exception("Unknown ApplicationType");
        }

        /// <summary>
        /// Register a constraint to this registry.
        /// </summary>
        public void RegisterConstraint(int elementTypeID, int ancestorTypeID, FileFormatVersions fileFormat, ApplicationType appType, SemanticConstraint constraint )
        {
            if ((fileFormat & _format) == _format && (appType & _appType) == _appType)
            {

                AddConstraintToDic(constraint, ancestorTypeID, _cleanList);
                AddConstraintToDic(constraint, elementTypeID, _semConstraintMap);
            }
        }

        public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl, ServerType delegateServer, ApplicationType applicationType)
        {
            var logger = new LoggerFactory()
                            .AddConsole()
                            .AddDebug()
                            .CreateLogger($"HelloWorld:{serverType}:{runtimeFlavor}:{architecture}:{delegateServer}");

            using (logger.BeginScope("HelloWorldTest"))
            {
                var deploymentParameters = new DeploymentParameters(Helpers.GetTestSitesPath(applicationType), serverType, runtimeFlavor, architecture)
                {
                    ApplicationBaseUriHint = applicationBaseUrl,
                    EnvironmentName = "HelloWorld", // Will pick the Start class named 'StartupHelloWorld',
                    ServerConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("Http.config") : null,
                    SiteName = "HttpTestSite", // This is configured in the Http.config
                    TargetFramework = runtimeFlavor == RuntimeFlavor.Clr ? "net451" : "netcoreapp1.0",
                    ApplicationType = applicationType
                };

                using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
                {
                    var deploymentResult = deployer.Deploy();
                    var httpClientHandler = new HttpClientHandler();
                    var httpClient = new HttpClient(httpClientHandler)
                    {
                        BaseAddress = new Uri(deploymentResult.ApplicationBaseUri),
                        Timeout = TimeSpan.FromSeconds(5),
                    };

                    // Request to base address and check if various parts of the body are rendered & measure the cold startup time.
                    var response = await RetryHelper.RetryRequest(() =>
                    {
                        return httpClient.GetAsync(string.Empty);
                    }, logger, deploymentResult.HostShutdownToken, retryCount: 30);

                    var responseText = await response.Content.ReadAsStringAsync();
                    try
                    {
                        Assert.Equal("Hello World", responseText);

                        response = await httpClient.GetAsync("/Path%3F%3F?query");
                        responseText = await response.Content.ReadAsStringAsync();
                        Assert.Equal("/Path??", responseText);

                        response = await httpClient.GetAsync("/Query%3FPath?query?");
                        responseText = await response.Content.ReadAsStringAsync();
                        Assert.Equal("?query?", responseText);
                    }
                    catch (XunitException)
                    {
                        logger.LogWarning(response.ToString());
                        logger.LogWarning(responseText);
                        throw;
                    }
                }
            }
        }

		/// <summary>
		/// Get the directory for the default location of the CruiseControl.NET data files.
		/// </summary>
		/// <param name="application">Type of the application. E.g. Server or WebDashboard.</param>
		/// <returns>The location of the CruiseControl.NET data files.</returns>
		public string GetDefaultProgramDataFolder(ApplicationType application)
		{
            if (application == ApplicationType.Unknown)
            {
                throw new ArgumentOutOfRangeException("application");
            }

            var pgfPath = AppDomain.CurrentDomain.BaseDirectory;
            return pgfPath;
		}

 public async Task NonWindowsOS(
     ServerType serverType,
     RuntimeFlavor runtimeFlavor,
     RuntimeArchitecture architecture,
     ApplicationType applicationType,
     string applicationBaseUrl)
 {
     var smokeTestRunner = new SmokeTests(_logger);
     await smokeTestRunner.SmokeTestSuite(serverType, runtimeFlavor, architecture, applicationType, applicationBaseUrl);
 }

 public static INodeCartridge GetHandler(ApplicationType applicationType)
 {
     switch (applicationType)
     {
         case ApplicationType.Mono:
             return new MonoCartridge();
         default:
             throw new MonoscapeException("Unknown application type found");
     }
 }

 public Application(ApplicationType type, string applicant, string destacc, string destname, string memo)
 {
     AppType = type;
     Applicant = applicant;
     DestAcc = destacc;
     DestName = destname;
     Memo = memo;
     CreationTime = DateTime.Now;
     AppType = ApplicationType.APerson;
 }

        public void Save(ApplicationType type)
        {
            if (type == ApplicationType.Application && MainFunc != null)
            {
                MethodInfo wrappedMain = WrapMain(MainFunc);
                _assemblyBuilder.SetEntryPoint(wrappedMain, PEFileKinds.ConsoleApplication);
            }

            SaveAssembly(_fileName, _assemblyBuilder);
        }

        public async Task NtlmAuthenticationTest(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, ApplicationType applicationType, string applicationBaseUrl)
        {
            using (_logger.BeginScope("NtlmAuthenticationTest"))
            {
                var musicStoreDbName = DbUtils.GetUniqueName();

                var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)
                {
                    PublishApplicationBeforeDeployment = true,
                    TargetFramework = runtimeFlavor == RuntimeFlavor.Clr ? "net451" : "netcoreapp1.0",
                    ApplicationType = applicationType,
                    ApplicationBaseUriHint = applicationBaseUrl,
                    EnvironmentName = "NtlmAuthentication", //Will pick the Start class named 'StartupNtlmAuthentication'
                    ServerConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("NtlmAuthentation.config") : null,
                    SiteName = "MusicStoreNtlmAuthentication", //This is configured in the NtlmAuthentication.config
                    UserAdditionalCleanup = parameters =>
                    {
                        DbUtils.DropDatabase(musicStoreDbName, _logger);
                    }
                };

                // Override the connection strings using environment based configuration
                deploymentParameters.EnvironmentVariables
                    .Add(new KeyValuePair<string, string>(
                        MusicStore.StoreConfig.ConnectionStringKey,
                        DbUtils.CreateConnectionString(musicStoreDbName)));

                using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, _logger))
                {
                    var deploymentResult = deployer.Deploy();
                    var httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
                    var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };

                    // Request to base address and check if various parts of the body are rendered & measure the cold startup time.
                    var response = await RetryHelper.RetryRequest(async () =>
                    {
                        return await httpClient.GetAsync(string.Empty);
                    }, logger: _logger, cancellationToken: deploymentResult.HostShutdownToken);

                    Assert.False(response == null, "Response object is null because the client could not " +
                        "connect to the server after multiple retries");

                    var validator = new Validator(httpClient, httpClientHandler, _logger, deploymentResult);

                    Console.WriteLine("Verifying home page");
                    await validator.VerifyNtlmHomePage(response);

                    Console.WriteLine("Verifying access to store with permissions");
                    await validator.AccessStoreWithPermissions();

                    _logger.LogInformation("Variation completed successfully.");
                }
            }
        }

 public async Task NonWindowsOS(
     ServerType serverType,
     RuntimeFlavor runtimeFlavor,
     RuntimeArchitecture architecture,
     ApplicationType applicationType,
     string applicationBaseUrl,
     bool noSource)
 {
     var testRunner = new PublishAndRunTests(_logger);
     await testRunner.Publish_And_Run_Tests(
         serverType, runtimeFlavor, architecture, applicationType, applicationBaseUrl, noSource);
 }

 public static LogServerComponent CreateLogServerComponent(ApplicationType appType,
                                                           LogServerComponentType logServer)
 {
     var ht = GetHost(appType, logServer.hostID);
     var component = new LogServerComponent(logServer.componentID, appType.applicationID, ht)
         {
             WorkingDir = logServer.workingDir,
             Port = logServer.port,
             HostName = ht.hostname
         };
     return component;
 }

        /// <summary>
        /// Function to save work detail.
        /// </summary>
        /// <param name="workDetail">work detail information</param>
        /// <param name="applicationType">Application type</param>
        public void InsertOrUpdate(WorkDetail workDetail, ApplicationType applicationType)
        {
            if (workDetail == null)
            {
                throw new ArgumentNullException(WorkDetailConst);
            }

            workDetail.Date = workDetail.Date.Date;
            workDetail.ApplicationID = (byte)applicationType;
            this.timesheetRepository.InsertOrUpdate(workDetail);
            this.unitOfWork.Save();
        }

 public static int GeneratePairedKey(string initialKey, ApplicationType appType)
 {
     string constantKey = "CashRegister2013";
     if (appType == ApplicationType.TaxCalculator)
     {
         constantKey = "TaxCalculator2014";
     }
     int hash = 23;
     hash = hash * 2 + initialKey.GetHashCode();
     hash = hash * 3 + constantKey.GetHashCode();
     hash = Math.Abs(hash);
     Debug.WriteLine("generated paired key: " + hash);
     return hash;
 }

 public static ForgeComponent CreateForgeComponent(ApplicationType appType, ForgeComponentType forge)
 {
     var ht = GetHost(appType, forge.hostID);
     var component = new ForgeComponent(forge.componentID, appType.applicationID, ht)
         {
             OutputDirectory = ResolveRelativePath(forge.workingDir, forge.outputDir),
             InputDirectory = ResolveRelativePath(forge.workingDir, forge.inputDir),
             LogDir = ResolveRelativePath(forge.workingDir, Path.GetDirectoryName(forge.logFile)),
             WorkingDir = forge.workingDir,
             DataPrefix = forge.outputPrefixName
         };
     LoadCustomProperties(component, forge);
     return component;
 }

        /// <summary>
        /// Inserts the specified work detail.
        /// </summary>
        /// <param name="workDetail">The work detail.</param>
        /// <param name="applicationType">Type of the application.</param>
        /// <returns>The total timesheet hours</returns>
        public decimal Insert(WorkDetail workDetail, ApplicationType applicationType)
        {
            if (workDetail == null)
            {
                throw new ArgumentNullException(WorkDetailConst);
            }

            workDetail.Date = workDetail.Date.Date;
            workDetail.ApplicationID = (byte)applicationType;
            var result = this.timesheetRepository.Insert(workDetail);
            this.unitOfWork.Save();

            return result;
        }

 public static DgidxComponent CreateDgidxComponent(ApplicationType appType, DgidxComponentType dgidx)
 {
     var ht = GetHost(appType, dgidx.hostID);
     var component = new DgidxComponent(dgidx.componentID, appType.applicationID, ht)
         {
             WorkingDir = dgidx.workingDir,
             OutputDirectory = ResolveRelativePath(dgidx.workingDir,
                                                   RemovePrefixNameFromDir(dgidx.outputPrefix)),
             InputDirectory = ResolveRelativePath(dgidx.workingDir, RemovePrefixNameFromDir(dgidx.inputPrefix)),
             LogDir = ResolveRelativePath(dgidx.workingDir, Path.GetDirectoryName(dgidx.logFile)),
             DataPrefix = GetDataPrefixFromDir(dgidx.outputPrefix)
         };
     LoadCustomProperties(component, dgidx);
     return component;
 }