public static void deleteTestDirectory(IBuildEngine buildEngine)
 {
     RemoveDir removeDirTask = new RemoveDir();
     removeDirTask.BuildEngine = buildEngine;
     removeDirTask.Directories = StringArrayToItemArray(new string[] { TestDirectory });
     removeDirTask.Execute();
 }

		public RemoteBuildEngine (Process proc, IBuildEngine engine)
		{
			this.proc = proc;
			this.engine = engine;

			Interlocked.Increment (ref count);
		}

        public bool Initialize(string taskName, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
        {
            var projectFileDirectory = Path.GetDirectoryName(taskFactoryLoggingHost.ProjectFileOfTaskNode);
            var thisAssemblyDirectory = Path.GetDirectoryName(this.GetType().Assembly.Location);
            _assemblyResolver.BeginResolving(thisAssemblyDirectory, projectFileDirectory);

            try
            {
                var engine = Ruby.CreateEngine();
                _taskScriptScope = engine.CreateScope();
                _taskScriptScope.ExecuteEmbeddedScript(RubyTaskScript);
                var rubyTaskBody = TaskBodyParser.Parse(taskBody);
                var scriptFile = projectFileDirectory.CombinePath(rubyTaskBody.Script).ToFullPath();
                var scriptContents = _fileSystem.GetFileContent(scriptFile);
                _taskScriptScope.Execute(scriptContents);
                _taskClass = engine.Runtime.Globals.GetVariable(taskName);
            }
            catch(Exception)
            {
                _assemblyResolver.Dispose();
                throw;
            }

            return true;
        }

 	public void Setup()
 	{
 		_mocks = new MockRepository();
     _task = _mocks.DynamicMock<ITask>();
     _engine = _mocks.DynamicMock<IBuildEngine>();
     _logger = new MsBuildLogger(new TaskLoggingHelper(_task));
 	}

        private static bool CheckForError(IBuildEngine engine, string error, bool exists)
        {
            var buildEngine = engine as BuildEngineStub;
            if (buildEngine == null)
            {
                Assert.Fail("Not a BuildEngineStub, cannot test with this");
            }
            if (buildEngine.Errors != null && buildEngine.Errors.Count > 0)
            {
                foreach (var anError in buildEngine.Errors)
                {
                    if (anError.StartsWith(error))
                    {
                        return exists;
                    }
                }
            }

            if (!exists) 
            {
                return true;
            }

            var sb = new StringBuilder();
            sb.AppendLine(error + " not found.  Actual errors: ");
            foreach (var anError in buildEngine.Errors)
            {
                sb.AppendLine(anError);
            }
            Assert.Fail(sb.ToString());

            // ReSharper disable HeuristicUnreachableCode
            return !exists;
            // ReSharper restore HeuristicUnreachableCode
        }

 /// <summary>
 /// Public constructor which can be used by task factories to assist them in logging messages.
 /// </summary>
 /// <param name="taskInstance">task containing an instance of this class</param>
 public TaskLoggingHelper(IBuildEngine buildEngine, string taskName)
 {
     ErrorUtilities.VerifyThrowArgumentNull(buildEngine, "buildEngine");
     ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName");
     _taskName = taskName;
     _buildEngine = buildEngine;
 }

 internal TlbReference(TaskLoggingHelper taskLoggingHelper, IComReferenceResolver resolverCallback, IEnumerable<string> referenceFiles, ComReferenceInfo referenceInfo, string itemName, string outputDirectory, bool hasTemporaryWrapper, bool delaySign, string keyFile, string keyContainer, bool noClassMembers, string targetProcessorArchitecture, bool includeTypeLibVersionInName, bool executeAsTool, string sdkToolsPath, IBuildEngine buildEngine, string[] environmentVariables) : base(taskLoggingHelper, resolverCallback, referenceInfo, itemName, outputDirectory, delaySign, keyFile, keyContainer, includeTypeLibVersionInName, executeAsTool, sdkToolsPath, buildEngine, environmentVariables)
 {
     this.hasTemporaryWrapper = hasTemporaryWrapper;
     this.noClassMembers = noClassMembers;
     this.targetProcessorArchitecture = targetProcessorArchitecture;
     this.referenceFiles = referenceFiles;
 }

		public void Setup()
		{
			task = MockRepository.GenerateStub<ITask>();
			engine = MockRepository.GenerateMock<IBuildEngine>();
			logger = new MsBuildLogger(new TaskLoggingHelper(task));

			task.Expect(t => t.BuildEngine).Return(engine).Repeat.Any();
		}

        /// <summary>
        /// Initialize the factory.
        /// </summary>
        public bool Initialize(string taskName, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
        {
            if (!String.Equals(taskName, TaskType.Name, StringComparison.OrdinalIgnoreCase))
            {
                ErrorUtilities.ThrowInternalError("Unexpected task name {0}.  Expected {1}", taskName, TaskType.Name);
            }

            return true;
        }

        protected void CheckoutProject(IBuildEngine engine, string path)
        {
            SvnCheckout task = new SvnCheckout();
            task.RepositoryPath = path;
            task.RepositoryUrl = RepositoryURL;
            task.BuildEngine = engine;

            task.Execute();
        }

        private void AssertFilesSubmitted(IBuildEngine engine)
        {
            string path = string.Format(RepositoryPathTemplate, DateTime.Now.Ticks);
            CheckoutProject(engine, path);

            string filePath = Path.Combine(path, "trunk\\DocumentA.txt");

            string contents = File.ReadAllText(filePath);
            Assert.That(contents, Is.EqualTo(ModifyString));
        }

 private SpyLogger(IBuildEngine buildEngine, string taskName)
     : base(buildEngine, taskName)
 {
     buildEngine.WhenAny(e => e.LogMessageEvent(null))
                .Do<BuildMessageEventArgs>(Log);
     buildEngine.WhenAny(e => e.LogWarningEvent(null))
                .Do<BuildWarningEventArgs>(Log);
     buildEngine.WhenAny(e => e.LogErrorEvent(null))
                .Do<BuildErrorEventArgs>(Log);
 }

 /// <summary>
 /// Construct.
 /// </summary>
 public AssemblyFoldersFromConfigResolver(string searchPathElement, GetAssemblyName getAssemblyName,
     FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion,
     ProcessorArchitecture targetProcessorArchitecture, bool compareProcessorArchitecture,
     IBuildEngine buildEngine, TaskLoggingHelper log)
     : base(
         searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion,
         targetProcessorArchitecture, compareProcessorArchitecture)
 {
     _buildEngine = buildEngine as IBuildEngine4;
     _taskLogger = log;
 }

    private SpyLogger(IBuildEngine buildEngine, string taskName, bool includeSourceInformation)
        : base(buildEngine, taskName)
    {
        this.includeSourceInformation = includeSourceInformation;

        buildEngine.WhenAny(e => e.LogMessageEvent(null))
                   .Do<BuildMessageEventArgs>(Log);
        buildEngine.WhenAny(e => e.LogWarningEvent(null))
                   .Do<BuildWarningEventArgs>(Log);
        buildEngine.WhenAny(e => e.LogErrorEvent(null))
                   .Do<BuildErrorEventArgs>(Log);
    }

 internal AxTlbBaseReference(TaskLoggingHelper taskLoggingHelper, IComReferenceResolver resolverCallback, ComReferenceInfo referenceInfo, string itemName, string outputDirectory, bool delaySign, string keyFile, string keyContainer, bool includeTypeLibVersionInName, bool executeAsTool, string toolPath, IBuildEngine buildEngine, string[] environmentVariables) : base(taskLoggingHelper, referenceInfo, itemName)
 {
     this.resolverCallback = resolverCallback;
     this.outputDirectory = outputDirectory;
     this.includeTypeLibVersionInName = includeTypeLibVersionInName;
     this.BuildEngine = buildEngine;
     this.EnvironmentVariables = environmentVariables;
     this.DelaySign = delaySign;
     this.ExecuteAsTool = executeAsTool;
     this.KeyFile = keyFile;
     this.KeyContainer = keyContainer;
     this.ToolPath = toolPath;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DlrTask"/> class.
        /// </summary>
        /// <param name="factory">The Factory</param>
        /// <param name="xmlElement">The XElement</param>
        /// <param name="taskFactoryLoggingHost">The taskFactoryLoggingHost</param>
        internal DlrTask(DlrTaskFactory factory, XElement xmlElement, IBuildEngine taskFactoryLoggingHost)
        {
            this.xelement = xmlElement;
            this.language = GetLanguage(xmlElement);

            var srs = new ScriptRuntimeSetup();
            srs.LanguageSetups.Add(IronRuby.Ruby.CreateRubySetup());
            srs.LanguageSetups.Add(IronPython.Hosting.Python.CreateLanguageSetup(null));
            var runtime = new ScriptRuntime(srs);
            this.engine = runtime.GetEngineByFileExtension(this.language);
            this.scope = this.engine.CreateScope();
            this.scope.log = this.Log;
        }

        /// <summary>
        /// Creates an instance of the task.
        /// </summary>
        public ITask CreateTask(IBuildEngine taskFactoryLoggingHost)
        {
            if (TaskType == typeof(MSBuild))
            {
                return new MSBuild();
            }
            else if (TaskType == typeof(CallTarget))
            {
                return new CallTarget();
            }

            ErrorUtilities.ThrowInternalError("Unexpected intrinsic task type {0}", TaskType);
            return null;
        }

        /// <summary>
        /// Create an instance of the ITask
        /// </summary>
        public ITask CreateTask(IBuildEngine taskFactoryLoggingHost)
        {
            // The assembly will have been compiled during class factory initialization, create an instance of it
            if (this.compiledAssembly != null)
            {
                // In order to use the resource strings from the tasks assembly we need to register the resources with the task logging helper.
                TaskLoggingHelper log = new TaskLoggingHelper(taskFactoryLoggingHost, nameOfTask);
                log.TaskResources = AssemblyResources.PrimaryResources;
                log.HelpKeywordPrefix = "MSBuild.";

                Type[] exportedTypes = this.compiledAssembly.GetExportedTypes();

                Type fullNameMatch = null;
                Type partialNameMatch = null;

                foreach (Type exportedType in exportedTypes)
                {
                    string exportedTypeName = exportedType.FullName;
                    if (exportedTypeName.Equals(nameOfTask, StringComparison.OrdinalIgnoreCase))
                    {
                        fullNameMatch = exportedType;
                        break;
                    } 
                    else if (partialNameMatch == null && exportedTypeName.EndsWith(nameOfTask, StringComparison.OrdinalIgnoreCase))
                    {
                        partialNameMatch = exportedType;
                    }
                }

                if (fullNameMatch == null && partialNameMatch == null)
                {
                    log.LogErrorWithCodeFromResources("CodeTaskFactory.CouldNotFindTaskInAssembly", nameOfTask);
                    return null;
                }

                this.taskInstance = this.compiledAssembly.CreateInstance(fullNameMatch != null ? fullNameMatch.FullName : partialNameMatch.FullName, true) as ITask;

                if (this.taskInstance == null)
                {
                    log.LogErrorWithCodeFromResources("CodeTaskFactory.NeedsITaskInterface", nameOfTask);
                    return null;
                }

                return this.taskInstance;
            }
            else
            {
                return null;
            }
        }

        public virtual bool Initialize(
        string taskName, 
        IDictionary<string, TaskPropertyInfo> parameterGroup, 
        string taskBody, 
        IBuildEngine taskFactoryLoggingHost)
        {
            Contract.Requires(!string.IsNullOrEmpty(taskName));
            Contract.Requires(parameterGroup != null);
            Contract.Requires(taskBody != null);
            Contract.Requires(taskFactoryLoggingHost != null);

            this.TaskXmlBody = taskBody;
            this.ParameterGroup = parameterGroup;

            return true;
        }

 private static ProjectInstance GetProjectInstance(IBuildEngine buildEngine)
 {
     var buildEngineType = buildEngine.GetType();
     var targetBuilderCallbackField = buildEngineType.GetField("targetBuilderCallback", SearchBindingFlags);
     if (targetBuilderCallbackField == null)
     {
         throw new InvalidProjectFileException("Could not extract targetBuilderCallback from " + buildEngineType.FullName);
     }
     var targetBuilderCallback = targetBuilderCallbackField.GetValue(buildEngine);
     var targetCallbackType = targetBuilderCallback.GetType();
     var projectInstanceField = targetCallbackType.GetField("projectInstance", SearchBindingFlags);
     if (projectInstanceField == null)
     {
         throw new InvalidProjectFileException("Could not extract projectInstance from " + targetCallbackType.FullName);
     }
     return (ProjectInstance)projectInstanceField.GetValue(targetBuilderCallback);
 }