public ManagedProjectReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, SolutionBase solution, TempFileCollection tfc, GacCache gacCache, DirectoryInfo outputDir)
            : base(referencesResolver, parent)
        {
            if (xmlDefinition == null) {
                throw new ArgumentNullException("xmlDefinition");
            }
            if (solution == null) {
                throw new ArgumentNullException("solution");
            }
            if (tfc == null) {
                throw new ArgumentNullException("tfc");
            }
            if (gacCache == null) {
                throw new ArgumentNullException("gacCache");
            }

            XmlAttribute privateAttribute = xmlDefinition.Attributes["Private"];
            if (privateAttribute != null) {
                _isPrivateSpecified = true;
                _isPrivate = bool.Parse(privateAttribute.Value);
            }

            // determine path of project file
            string projectFile = solution.GetProjectFileFromGuid(
                xmlDefinition.GetAttribute("Project"));

            // load referenced project
            _project = LoadProject(solution, tfc, gacCache, outputDir, projectFile);
        }

		[SecurityPermission (SecurityAction.Assert, ControlPrincipal = true)] // UnmanagedCode "covers" more than ControlPrincipal
		public static Int32 ExecWaitWithCapture (IntPtr userToken, string cmd, string currentDir, TempFileCollection tempFiles, ref string outputName, ref string errorName)
		{
			// WindowsImpersonationContext implements IDisposable only in 2.0
			using (WindowsImpersonationContext context = WindowsIdentity.Impersonate (userToken)) {
				return InternalExecWaitWithCapture (cmd, currentDir, tempFiles, ref outputName, ref errorName);
			}
		}

        public static string Execute(string strCmd, bool bDropFirstLineOfOutput)
        {
            string output = "";
            string error  = "";

            TempFileCollection tf = new TempFileCollection();
            Executor.ExecWaitWithCapture(strCmd, tf, ref output, ref error);

            StreamReader sr = File.OpenText(output);
            StringBuilder strBuilder = new StringBuilder();
            string strLine = null;
            bool bFirstLine = true;

            while (null != (strLine = sr.ReadLine()))
            {
                if ("" != strLine)
                {
                    if (bFirstLine && bDropFirstLineOfOutput)
                    {
                        bFirstLine = false;
                        continue;
                    }
                    strBuilder.Append(strLine);
                    strBuilder.Append("\r\n");
                }
            }
            sr.Close();

            File.Delete(output);
            File.Delete(error);

            return strBuilder.ToString();
        }

 public void ViewLog()
 {
     TempFileCollection tempFiles = new TempFileCollection();
     FileInfo msgFile = new FileInfo(tempFiles.AddExtension("txt"));
     File.WriteAllText(msgFile.FullName, Session.Log, Encoding.ASCII);
     Process.Start(msgFile.FullName);
 }

 public void FileLoggerTest()
 {
     var tfc = new TempFileCollection();
     var fileName = tfc.AddExtension("txt");
     var logger = LoggerFactory.Instance.GetLogger(LogType.File, fileName);
     logger.Log(TEST_LOG);
 }

 public void Ctor_Empty()
 {
     var collection = new TempFileCollection();
     Assert.Equal(0, collection.Count);
     Assert.Empty(collection.TempDir);
     Assert.False(collection.KeepFiles);
 }

		public void FixtureSetUp ()
		{
			// at full trust
			temps = new TempFileCollection ();
			assembly = Assembly.GetExecutingAssembly ();
			path = assembly.Location;
		}

 public void Ctor_String(string tempDir)
 {
     var collection = new TempFileCollection(tempDir);
     Assert.Equal(0, collection.Count);
     Assert.Equal(tempDir ?? string.Empty, collection.TempDir);
     Assert.False(collection.KeepFiles);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProjectBase" /> class.
        /// </summary>
        protected ProjectBase(XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection temporaryFiles, GacCache gacCache, ReferencesResolver referencesResolver, DirectoryInfo outputDir) {
            if (xmlDefinition == null) {
                throw new ArgumentNullException("xmlDefinition");
            }
            if (solutionTask == null) {
                throw new ArgumentNullException("solutionTask");
            }
            if (temporaryFiles == null) {
                throw new ArgumentNullException("temporaryFiles");
            }
            if (gacCache == null) {
                throw new ArgumentNullException("gacCache");
            }
            if (referencesResolver == null) {
                throw new ArgumentNullException("referencesResolver");
            }

            _projectConfigurations = new ConfigurationDictionary();
            _buildConfigurations = new ConfigurationDictionary();
            _extraOutputFiles = CollectionsUtil.CreateCaseInsensitiveHashtable();

            // ensure the specified project is actually supported by this project
            VerifyProjectXml(xmlDefinition);

            _solutionTask = solutionTask;
            _temporaryFiles = temporaryFiles;
            _outputDir = outputDir;
            _gacCache = gacCache;
            _refResolver = referencesResolver;
            _productVersion = DetermineProductVersion(xmlDefinition);
        }

 public void Ctor_String_Bool(string tempDir, bool keepFiles)
 {
     var collection = new TempFileCollection(tempDir, keepFiles);
     Assert.Equal(0, collection.Count);
     Assert.Equal(tempDir ?? string.Empty, collection.TempDir);
     Assert.Equal(keepFiles, collection.KeepFiles);
 }

		public void FileSerializeMatchesLength() {
			using (TempFileCollection tfc = new TempFileCollection()) {
				string file = tfc.AddExtension(".txt");
				File.WriteAllText(file, "sometext");
				var part = MultipartPostPart.CreateFormFilePart("someformname", file, "text/plain");
				VerifyLength(part);
			}
		}

 public Compilador( string directorio, string nombre, string archivoSalida, string archivoError )
 {
     archivosTemporales = new TempFileCollection();
     this.directorio = directorio;
     this.nombre = nombre;
     this.archivoSalida = archivoSalida;
     this.archivoError = archivoError;
 }

 protected SolutionBase(SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver) : this(tfc, solutionTask) {
     if (solutionTask.SolutionFile != null) {
         _file = solutionTask.SolutionFile;
     } else {
         LoadProjectGuids(new ArrayList(solutionTask.Projects.FileNames), false);
         LoadProjectGuids(new ArrayList(solutionTask.ReferenceProjects.FileNames), true);
         LoadProjects(gacCache, refResolver, CollectionsUtil.CreateCaseInsensitiveHashtable());
     }
 }

		public void MultiPartPostAscii() {
			using (TempFileCollection tfc = new TempFileCollection()) {
				string file = tfc.AddExtension("txt");
				File.WriteAllText(file, "sometext");
				this.VerifyFullPost(new List<MultipartPostPart> {
					MultipartPostPart.CreateFormPart("a", "b"),
					MultipartPostPart.CreateFormFilePart("SomeFormField", file, "text/plain"),
				});
			}
		}

 public void MetaData()
 {
     string SAVfilename;
     using (System.CodeDom.Compiler.TempFileCollection tfc = new System.CodeDom.Compiler.TempFileCollection())
     {
         SAVfilename = tfc.AddExtension("sav", true);
         SpssConvert.ToFile(tblTest, tblTest.Select(), SAVfilename, FillInMetaData);
         Console.WriteLine("The file with metadata is stored at: " + SAVfilename);
     }
 }

		public void MultiPartPostMultiByteCharacters() {
			using (TempFileCollection tfc = new TempFileCollection()) {
				string file = tfc.AddExtension("txt");
				File.WriteAllText(file, "\x1020\x818");
				this.VerifyFullPost(new List<MultipartPostPart> {
					MultipartPostPart.CreateFormPart("a", "\x987"),
					MultipartPostPart.CreateFormFilePart("SomeFormField", file, "text/plain"),
				});
			}
		}

        public MSBuildProject(SolutionBase solution, string projectPath, XmlElement xmlDefinition, SolutionTask solutionTask, TempFileCollection tfc, GacCache gacCache, ReferencesResolver refResolver, DirectoryInfo outputDir)
            : base(xmlDefinition, solutionTask, tfc, gacCache, refResolver, outputDir)
        {
            string cfgname = solutionTask.Configuration;
            string platform = solutionTask.Platform;

            _msbuild = MSBuildEngine.CreateMSEngine(solutionTask);
            _msproj = new Microsoft.Build.BuildEngine.Project(_msbuild);
            _msproj.FullFileName = projectPath;
            _msproj.LoadXml(xmlDefinition.OuterXml);
            _msproj.GlobalProperties.SetProperty("Configuration", cfgname);
            SetPlatform (platform);
            if (outputDir != null) _msproj.GlobalProperties.SetProperty("OutputPath", outputDir.FullName);

            //evaluating
            _guid = _msproj.GetEvaluatedProperty("ProjectGuid");
            _projectDirectory = new DirectoryInfo(_msproj.GetEvaluatedProperty("ProjectDir"));
            _projectPath = _msproj.GetEvaluatedProperty("ProjectPath");

            ProjectEntry projectEntry = solution.ProjectEntries [_guid];
            if (projectEntry != null && projectEntry.BuildConfigurations != null) {
                foreach (ConfigurationMapEntry ce in projectEntry.BuildConfigurations) {
                    Configuration projectConfig = ce.Value;
                    ProjectConfigurations[projectConfig] = new MSBuildConfiguration(this, _msproj, projectConfig);
                }
            } else {
                Configuration projectConfig = new Configuration (cfgname, platform);
                ProjectConfigurations[projectConfig] = new MSBuildConfiguration(this, _msproj, projectConfig);
            }

            //references
            _references = new ArrayList();
            Microsoft.Build.BuildEngine.BuildItemGroup refs = _msproj.GetEvaluatedItemsByName("Reference");
            foreach (Microsoft.Build.BuildEngine.BuildItem r in refs) {
                string rpath = r.FinalItemSpec;
                string priv = r.GetMetadata("Private");
                string hintpath = r.GetMetadata("HintPath");

                ReferenceBase reference = new MSBuildAssemblyReference(
                    xmlDefinition, ReferencesResolver, this, gacCache,
                    rpath, priv, hintpath);
                _references.Add(reference);
            }
            refs = _msproj.GetEvaluatedItemsByName("ProjectReference");
            foreach (Microsoft.Build.BuildEngine.BuildItem r in refs) {
                string pguid = r.GetMetadata("Project");
                string pname = r.GetMetadata("Name");
                string rpath = r.FinalItemSpec;
                string priv = r.GetMetadata("Private");
                ReferenceBase reference = new MSBuildProjectReference(
                    ReferencesResolver, this, solution, tfc, gacCache, outputDir,
                    pguid, pname, rpath, priv);
                _references.Add(reference);
            }
        }

		public void Constructor1_Deny_Unrestricted ()
		{
			TempFileCollection tfc = new TempFileCollection (temp);
			Assert.AreEqual (0, tfc.Count, "Count");
			Assert.IsFalse (tfc.KeepFiles, "KeepFiles");
			Assert.AreEqual (temp, tfc.TempDir, "TempDir");
			tfc.AddFile ("main.cs", false);
			tfc.CopyTo (array, 0);
			tfc.Delete ();
			(tfc as IDisposable).Dispose ();
		}

        public void TestInit()
        {
            this.temporaryFiles = new TempFileCollection(this.TestContext.TestRunDirectory, keepFiles: false);

            this.serviceProvider = new ConfigurableServiceProvider();

            this.fileSystem = new ConfigurableFileSystem();
            this.serviceProvider.RegisterService(typeof(IFileSystem), this.fileSystem);

            this.testSubject = new RuleSetSerializer(this.serviceProvider);
        }

 public MSBuildProjectReference(
     ReferencesResolver referencesResolver, ProjectBase parent,
     SolutionBase solution, TempFileCollection tfc,
     GacCache gacCache, DirectoryInfo outputDir,
     string pguid, string pname, string rpath, string priv)
     
     : base(referencesResolver, parent) {
     _helper = new MSBuildReferenceHelper(priv, true);
     string projectFile = solution.GetProjectFileFromGuid(pguid);
     _project = LoadProject(solution, tfc, gacCache, outputDir, projectFile);
 }