public DTECheckFrm(IEnvironment env)
        {
            _dteo = new DTEOperation(env, vsCE.Events.SolutionEventType.General);

            InitializeComponent();
            Icon = Resource.Package_32;
        }

 public RepositoryFactory(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase httpContext)
 {
     _environment = environment;
     _settings = settings;
     _traceFactory = traceFactory;
     _httpContext = httpContext;
 }

 public MSBuildBuildEngine(IFileSystem fileSystem, IEnvironment environment)
     : base(fileSystem,environment)
 {
     Profile = new List<string> { environment.ExecutionEnvironment.Profile };
     Platform = new List<string> { environment.ExecutionEnvironment.Platform };
     Project = new List<string>();
 }

 public InfoRefsService(ITracer tracer, IGitServer gitServer, IEnvironment environment, RepositoryConfiguration configuration)
 {
     _gitServer = gitServer;
     _tracer = tracer;
     _deploymentTargetPath = environment.DeploymentTargetPath;
     _configuration = configuration;
 }

 public HGeneratorIterable(IEnvironment environment, ReadOnlyList<GeneratorStep> steps, ReadOnlyList<string> variableDeclarations, ILexicalEnvironment scope)
     : base(environment)
 {
     Steps = steps;
     VariableDeclarations = variableDeclarations;
     Scope = scope;
 }

        public static void MyClassInitialize(TestContext testContext)
        {
            ObjectFactory.Inject<IEnvironment>(new Environment());
            ObjectFactory.Inject<IDatabaseConnection>(new DatabaseConnection());

            _environment = ObjectFactory.GetInstance<IEnvironment>();
        }

        public static string GetAvatarPreselection(this Avatar avatar, IEnvironment env)
        {
            if (avatar.isDefault)
                return "checked=\"checked\"";

            return string.Empty;
        }

 public AppVeyor(Logger logger, IEnvironment environment, IHttpClientFactory httpClientFactory)
 {
     _logger = logger;
     _environment = environment;
     _httpClientFactory = httpClientFactory;
     _appVeyorApiUrl = _environment.GetEnvironmentVariable("APPVEYOR_API_URL");
 }

        /// <summary>
        /// Setup constructor
        /// </summary>
        public CompositeEditorController(
            IEnvironment env,
            ICompositeEditorView view,
            object composite,
            IComponentUiElementFactory uiFactory,
            IComponentDependencies dependencies,
            IComponentAggregator aggregator
            )
            : base(view)
        {
            Arguments.CheckNotNull( env, "env" );
            Arguments.CheckNotNull( uiFactory, "uiFactory" );
            Arguments.CheckNotNull( dependencies, "dependencies" );
            Arguments.CheckNotNull( aggregator, "aggregator" );

            m_View = view;
            m_Environment = env;
            m_UiFactory = uiFactory;
            m_Dependencies = dependencies;
            m_Aggregator = aggregator;

            m_View.SelectionChanged += OnSelectionChanged;
            m_View.EditComponent += OnEditComponent;
            m_View.RemoveSelectedComponent += OnRemoveComponent;
            m_View.AddToComponent += OnAddComponent;

            ResetView( composite );
        }

 public NullRepository(IEnvironment environment, ITraceFactory traceFactory, HttpContextBase httpContext)
 {
     _environment = environment;
     _traceFactory = traceFactory;
     _httpContext = httpContext;
     _changeSetKey = Path.Combine(_environment.RepositoryPath, "changeset");
 }

 public static IEnumerable<IGrouping<string, Exports.ICommand>> CommandExports(this IPackageManager manager, IEnvironment environment)
 {
     var projectCommands = manager.GetProjectExports<Exports.ICommand>(environment.Descriptor, environment.ProjectRepository, environment.ExecutionEnvironment).SelectMany(x=>x).GroupBy(x=>x.Package.Name);
     var consumedPackages = projectCommands.Select(x => x.Key).ToList();
     var systemCommands = manager.GetSystemExports<Exports.ICommand>(environment.SystemRepository, environment.ExecutionEnvironment).SelectMany(x => x).GroupBy(x => x.Package.Name);
     return projectCommands.Concat(systemCommands.Where(x => consumedPackages.ContainsNoCase(x.Key) == false));
 }

        private static void startTheEnvironment(IList<LogEntry> list, IEnvironment environment, params Action<IInstaller, IPackageLog>[] actions)
        {
            var log = new PackageLog();

            try
            {
                var installers = environment.StartUp(log);

                // This needs to happen regardless, but we want these logs put in before
                // logs for the installers, so we don't do it in the finally{}
                AddPackagingLogEntries(list);

                executeInstallers(list, installers, actions);

            }
            catch (Exception ex)
            {
                AddPackagingLogEntries(list);
                log.MarkFailure(ex.ToString());
            }
            finally
            {
                list.Add(LogEntry.FromPackageLog(environment, log));
                environment.SafeDispose();
            }
        }

        public static DeploymentStatusFile Open(string id, IEnvironment environment, IAnalytics analytics, IOperationLock statusLock)
        {
            return statusLock.LockOperation(() =>
            {
                string path = Path.Combine(environment.DeploymentsPath, id, StatusFile);

                if (!FileSystemHelpers.FileExists(path))
                {
                    return null;
                }

                try
                {
                    XDocument document = null;
                    using (var stream = FileSystemHelpers.OpenRead(path))
                    {
                        document = XDocument.Load(stream);
                    }

                    return new DeploymentStatusFile(id, environment, statusLock, document);
                }
                catch (Exception ex)
                {
                    // in the scenario where w3wp is abruptly terminated while xml is being written,
                    // we may end up with corrupted xml.  we will handle the error and remove the problematic directory.
                    analytics.UnexpectedException(ex);

                    FileSystemHelpers.DeleteDirectorySafe(Path.GetDirectoryName(path), ignoreErrors: true);

                    // it is ok to return null as callers already handle null.
                    return null;
                }
            }, DeploymentStatusManager.LockTimeout);
        }

        IHost IIsolator.Build(IEnvironment environment)
        {
            var domainName = _options.DomainName ?? Guid.NewGuid().ToString();
            var strongName = typeof (Jail).Assembly.Evidence.GetHostEvidence<StrongName>();

            var domain = System.AppDomain.CreateDomain(domainName, null, _options.Setup, _options.Permissions, strongName, typeof(object).Assembly.Evidence.GetHostEvidence<StrongName>());

            var host = (AppDomainHost) Activator.CreateInstanceFrom(domain,
                typeof (AppDomainHost).Assembly.CodeBase,
                typeof (AppDomainHost).FullName)
                .Unwrap();

            host.AddAssembly(typeof (Jail).Assembly.GetName());

            foreach (var registration in environment.GetRegistrations())
            {
                if (registration is AssemblyName)
                {
                    host.AddAssembly((AssemblyName) registration);
                }
                else if (registration is InMemoryAssembly)
                {
                    host.AddAssembly((InMemoryAssembly) registration);
                }
            }

            return host;
        }

 public AspNet5Builder(IEnvironment environment, IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string sourcePath, string projectPath, bool isConsoleApp)
     : base(environment, settings, propertyProvider, sourcePath)
 {
     _projectPath = projectPath;
     _sourcePath = sourcePath;
     _isConsoleApp = isConsoleApp;
 }

 public void SetHomePath(IEnvironment environment)
 {
     if (!String.IsNullOrEmpty(environment.RootPath))
     {
         SetHomePath(environment.RootPath);
     }
 }

 public static IQueryValue CClamp(IEnvironment env, IQueryValue[] args)
 {
     FunctionUtils.CheckArgumentCountEqual("cclamp", 1, args.Length);
     Color color = args[0].Color;
     color.Clamp();
     return new ColorValue() {Color = color};
 }

        private static void OldRunsCleanup(string jobName, IFileSystem fileSystem, IEnvironment environment, ITraceFactory traceFactory, IDeploymentSettingsManager settings)
        {
            // if max is 5 and we have 5 we still want to remove one to make room for the next
            // that's why we decrement max value by 1
            int maxRuns = settings.GetMaxJobRunsHistoryCount() - 1;

            string historyPath = Path.Combine(environment.JobsDataPath, Constants.TriggeredPath, jobName);
            DirectoryInfoBase historyDirectory = fileSystem.DirectoryInfo.FromDirectoryName(historyPath);
            if (!historyDirectory.Exists)
            {
                return;
            }

            DirectoryInfoBase[] historyRunsDirectories = historyDirectory.GetDirectories();
            if (historyRunsDirectories.Length <= maxRuns)
            {
                return;
            }

            var directoriesToRemove = historyRunsDirectories.OrderByDescending(d => d.Name).Skip(maxRuns);
            foreach (DirectoryInfoBase directory in directoriesToRemove)
            {
                try
                {
                    directory.Delete(true);
                }
                catch (Exception ex)
                {
                    traceFactory.GetTracer().TraceError(ex);
                }
            }
        }

        internal static IDynamic IsArray(IEnvironment environment, IArgs args)
        {
            // 15.4.3.2 Array.isArray ( arg )

            var arg = args[0] as IObject;
            return environment.CreateBoolean(arg != null && arg.Class == "Array");
        }

 public override IDynamic CreateIterator(IEnvironment environment, IArgs args)
 {
     var scope = Scope.NewDeclarativeEnvironment();
     var generator = new Generator(new GeneratorSteps(Steps));
     var iterator = new HGeneratorIterator(environment, generator, VariableDeclarations, scope);
     return iterator;
 }