202if (File.Exists(path))

228File.WriteAllText(fileName, completeOutput.ToString(), Encoding.UTF8); 229File.WriteAllText(uniqueFileName, uniqueOutput.ToString(), Encoding.UTF8); 287if (File.Exists(path))

20if (File.Exists(settingsFilePath)) 22var existingContent = await File.ReadAllTextAsync(settingsFilePath, cancellationToken); 42await File.WriteAllTextAsync(settingsFilePath, jsonContent, cancellationToken); 49if (!File.Exists(settingsFilePath)) 56var existingContent = await File.ReadAllTextAsync(settingsFilePath, cancellationToken); 71await File.WriteAllTextAsync(settingsFilePath, jsonContent, cancellationToken); 103if (File.Exists(settingsFilePath)) 130var content = await File.ReadAllTextAsync(filePath, cancellationToken);

21if (File.Exists(settingsFilePath)) 31if (File.Exists(globalSettingsFile.FullName))

43Assert.True(File.Exists(settingsPath)); 45var json = await File.ReadAllTextAsync(settingsPath); 66Assert.True(File.Exists(settingsPath)); 68var json = await File.ReadAllTextAsync(settingsPath); 91Assert.True(File.Exists(settingsPath)); 93var json = await File.ReadAllTextAsync(settingsPath); 125var json = await File.ReadAllTextAsync(settingsPath); 245var json = await File.ReadAllTextAsync(settingsPath);

21await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 64await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 96await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 138await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 179await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 223await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file.");

210File.Delete(migrationFile);

51await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 55await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 89await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 93await File.WriteAllTextAsync(targetAppHostProjectFile.FullName, "Not a real apphost"); 124await File.WriteAllTextAsync(realAppHostProjectFile.FullName, "Not a real apphost project"); 167await File.WriteAllTextAsync(projectFile1.FullName, "Not a real project file."); 170await File.WriteAllTextAsync(projectFile2.FullName, "Not a real project file."); 189await File.WriteAllTextAsync(appHostProject.FullName, "Not a real apphost project."); 192await File.WriteAllTextAsync(webProject.FullName, "Not a real web project."); 239await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 257await File.WriteAllTextAsync(projectFile.FullName, "Not a real project file."); 278await File.WriteAllTextAsync(appHostProjectFile.FullName, "Not a real project file."); 302var settingsJson = await File.ReadAllTextAsync(settingsFile.FullName);

176await File.WriteAllTextAsync(configPath, configJson.ToString()).DefaultTimeout(); 219await File.WriteAllTextAsync(configPath, configJson.ToString()).DefaultTimeout();

181File.Delete(browserTokenConfigFile); 213await File.WriteAllTextAsync(browserTokenConfigFile, changedFrontendBrowserToken).DefaultTimeout(); 228File.Delete(browserTokenConfigFile); 559await File.WriteAllTextAsync(configFilePath, configJson.ToString()).DefaultTimeout(); 582File.Delete(configFilePath); 802await File.WriteAllTextAsync(browserTokenConfigFile, browserToken);

20if (!string.IsNullOrEmpty(browserPath) && !File.Exists(browserPath)) 31if (File.Exists(probePath))

14if (Directory.Exists(Path.Combine(repoRoot.FullName, ".git")) || File.Exists(Path.Combine(repoRoot.FullName, ".git")))

20if (!string.IsNullOrEmpty(browserPath) && !File.Exists(browserPath)) 31if (File.Exists(probePath))

14if (Directory.Exists(Path.Combine(repoRoot.FullName, ".git")) || File.Exists(Path.Combine(repoRoot.FullName, ".git")))

65File.WriteAllText(Path.Combine(dir, "Directory.Build.props"), "<Project />"); 66File.WriteAllText(Path.Combine(dir, "Directory.Build.targets"), "<Project />"); 73File.Copy(srcNuGetConfigPath, targetNuGetConfigPath); 107File.WriteAllText(Path.Combine(rootDir, "Directory.Build.props"), "<Project />"); 108File.WriteAllText(Path.Combine(rootDir, "Directory.Build.targets"), "<Project />"); 131var csprojContent = File.ReadAllText(csprojPath); 151File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "EndPointWriterHook_cs"), Path.Combine(project.AppHostProjectDirectory, "EndPointWriterHook.cs")); 153string programCs = File.ReadAllText(programCsPath); 156File.WriteAllText(programCsPath, programCs);

105.FirstOrDefault(File.Exists); 128.FirstOrDefault(File.Exists);

18public string CustomHiveDirectory => File.Exists(_stampFilePath) 37if (BuildEnvironment.IsRunningOnCI && File.Exists(_stampFilePath)) 51if (File.Exists(_stampFilePath)) 80File.WriteAllText(_stampFilePath, "");

52using (var fileStream = File.OpenWrite(tempFileName)) 62if (!File.Exists(finalFilePath)) 64File.Copy(tempFileName, finalFilePath, overwrite: true); 69File.Delete(tempFileName);

25if (!File.Exists(sourceFilename)) 30using var sourceStream = File.OpenRead(sourceFilename);

178if (File.Exists(fullPath))

861if (!Directory.Exists(sourceFullPath) && !File.Exists(sourceFullPath))

45if (!File.Exists(dcpPath))

172if (!File.Exists(dcpExePath))

76var settingsContent = await File.ReadAllTextAsync(settingsPath, cancellationToken).ConfigureAwait(false); 135await File.WriteAllTextAsync(settingsPath, settingsContent, cancellationToken).ConfigureAwait(false); 177if (!File.Exists(path)) 185using var stream = File.Open(path, FileMode.CreateNew);

74if (!File.Exists(projectMetadata.ProjectPath)) 88if (!File.Exists(launchSettingsFilePath)) 93using var stream = File.OpenRead(launchSettingsFilePath);

67File.Move(tempFilename, _secretsFilePath, overwrite: true); 75File.WriteAllText(_secretsFilePath, json, Encoding.UTF8);

106File.WriteAllText(path, TemplateString); 118using var fs = File.OpenWrite(path); 150return File.ReadAllText(TemplateFile); 297File.Delete(Path);

90File.WriteAllText(moduleSourcePath, compiledBicep.Value); 93File.Copy(moduleSourcePath, moduleDestinationPath, true); 106_generatedBicep = File.ReadAllText(template.Path);

149File.Copy(file.Path, modulePath, true); 310File.Copy(file.Path, modulePath, true); 416await File.WriteAllTextAsync(bicepPath, compiledBicep.Value).ConfigureAwait(false);

75return FindFullPathFromPath(command, Environment.GetEnvironmentVariable("PATH"), File.Exists);

40var userSecrets = userSecretsPath is not null && File.Exists(userSecretsPath) 41? JsonNode.Parse(await File.ReadAllTextAsync(userSecretsPath, cancellationToken).ConfigureAwait(false), 62await File.WriteAllTextAsync(userSecretsPath, flattenedSecrets.ToJsonString(s_jsonSerializerOptions), cancellationToken).ConfigureAwait(false);

74if (!File.Exists(projectMetadata.ProjectPath)) 88if (!File.Exists(launchSettingsFilePath)) 93using var stream = File.OpenRead(launchSettingsFilePath);

184File.WriteAllText(Path.Combine(directory.FullName, "Dockerfile"), "");

62File.WriteAllText(Path.Combine(directory.FullName, "Dockerfile"), "");

35Assert.True(File.Exists(mainBicepPath)); 36var mainBicep = File.ReadAllText(mainBicepPath); 39Assert.True(File.Exists(envBicepPath)); 40var envBicep = File.ReadAllText(envBicepPath); 72Assert.True(File.Exists(mainBicepPath)); 73var mainBicep = File.ReadAllText(mainBicepPath); 124Assert.True(File.Exists(mainBicepPath)); 125var content = File.ReadAllText(mainBicepPath); 172var mainBicep = File.ReadAllText(Path.Combine(tempDir.FullName, "main.bicep")); 173var storageBicep = File.ReadAllText(Path.Combine(tempDir.FullName, "storage", "storage.bicep")); 208Assert.True(File.Exists(mainBicepPath)); 209var mainBicep = File.ReadAllText(mainBicepPath); 213Assert.True(File.Exists(includedStorageBicepPath), "Included storage should have a bicep file generated"); 217Assert.False(File.Exists(excludedStorageBicepPath), "Excluded storage should not have a bicep file generated");

476File.WriteAllText(configJsonPath, source); 497File.Delete(configJsonPath);

37if (pathNode?.ToString() is not { } path || !File.Exists(Path.Combine(manifestDir, path))) 42var bicepText = await File.ReadAllTextAsync(Path.Combine(manifestDir, path));

42var sbBicep = await File.ReadAllTextAsync(Path.Combine(tempDir.FullName, "sb.module.bicep")); 44var sqlBicep = await File.ReadAllTextAsync(Path.Combine(tempDir.FullName, "sql-server.module.bicep"));

557File.WriteAllText(configJsonPath, """ 593File.Delete(configJsonPath); 782File.WriteAllText(configJsonPath,

25await File.WriteAllTextAsync(dockerFilePath, dockerfile); 49Assert.True(File.Exists(infoFile)); 51var infoContent = await File.ReadAllTextAsync(infoFile);

147await File.WriteAllTextAsync(outputFile, composeOutput, cancellationToken).ConfigureAwait(false); 202File.Copy(file.SourcePath, sourcePath);

14if (!File.Exists(path)) 19foreach (var line in File.ReadAllLines(path)) 53File.WriteAllLines(path, _lines);

99Assert.True(File.Exists(composePath)); 100Assert.True(File.Exists(envPath)); 102await Verify(File.ReadAllText(composePath), "yaml") 103.AppendContentAsFile(File.ReadAllText(envPath), "env"); 132Assert.True(File.Exists(composePath)); 133Assert.True(File.Exists(envPath)); 135await Verify(File.ReadAllText(composePath), "yaml") 136.AppendContentAsFile(File.ReadAllText(envPath), "env"); 159Assert.True(File.Exists(composePath)); 161await Verify(File.ReadAllText(composePath), "yaml"); 194Assert.True(File.Exists(composePath)); 243Assert.True(File.Exists(composePath)); 245Assert.True(File.Exists(envPath)); 247await Verify(File.ReadAllText(composePath), "yaml") 248.AppendContentAsFile(File.ReadAllText(envPath), "env"); 270Assert.True(File.Exists(envFilePath)); 271var firstContent = File.ReadAllText(envFilePath).Replace("PARAM1=", "PARAM1=changed"); 272File.WriteAllText(envFilePath, firstContent); 275Assert.True(File.Exists(envFilePath)); 276var secondContent = File.ReadAllText(envFilePath); 311Assert.True(File.Exists(envFilePath)); 312var firstContent = File.ReadAllText(envFilePath).Replace("PARAM1=", "PARAM1=changed"); 313File.WriteAllText(envFilePath, firstContent); 316Assert.True(File.Exists(envFilePath)); 317var secondContent = File.ReadAllText(envFilePath); 342Assert.True(File.Exists(composePath)); 344var composeFile = File.ReadAllText(composePath); 368Assert.True(File.Exists(composePath)); 370var composeContent = File.ReadAllText(composePath); 394Assert.True(File.Exists(composePath)); 396var composeContent = File.ReadAllText(composePath); 422Assert.True(File.Exists(composePath)); 424var composeContent = File.ReadAllText(composePath); 454Assert.True(File.Exists(composePath)); 456var composeContent = File.ReadAllText(composePath); 479Assert.False(File.Exists(composePath));

55Assert.True(File.Exists(composeFile), "Docker Compose file was not created."); 80Assert.True(File.Exists(composeFile), "Docker Compose file was not created."); 82var composeContent = File.ReadAllText(composeFile);

141File.SetUnixFileMode(bindMountPath, BindMountPermissions);

152File.SetUnixFileMode(bindMountPath, BindMountPermissions);

183File.WriteAllText(filePath, string.Empty);

164await File.WriteAllTextAsync(outputFile, valuesYaml, cancellationToken).ConfigureAwait(false); 184await File.WriteAllTextAsync(outputFile, chartYaml, cancellationToken).ConfigureAwait(false);

30await Verify(File.ReadAllText(chartYaml), "yaml") 31.AppendContentAsFile(File.ReadAllText(valuesYaml), "yaml") 32.AppendContentAsFile(File.ReadAllText(deploymentYaml), "yaml");

68settingsTask = Verify(File.ReadAllText(filePath), fileExtension); 72settingsTask = settingsTask.AppendContentAsFile(File.ReadAllText(filePath), fileExtension); 103Assert.True(File.Exists(deploymentPath)); 105var content = await File.ReadAllTextAsync(deploymentPath); 162settingsTask = Verify(File.ReadAllText(filePath), fileExtension); 166settingsTask = settingsTask.AppendContentAsFile(File.ReadAllText(filePath), fileExtension); 213settingsTask = Verify(File.ReadAllText(filePath), fileExtension); 217settingsTask = settingsTask.AppendContentAsFile(File.ReadAllText(filePath), fileExtension);

264await File.WriteAllTextAsync(initFilePath, $$""" 287File.SetUnixFileMode(initFilePath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.GroupRead | UnixFileMode.OtherRead); 362await File.WriteAllTextAsync(initFilePath, $$"""

245File.SetUnixFileMode(configStoreFilename, FileMode644); 254File.Delete(tempConfigFile);

279using var stream = File.OpenRead(volume.Source!);

311File.WriteAllText(Path.Combine(bindMountPath, "init.sql"), """ 398File.WriteAllText(Path.Combine(initFilesPath, "init.sql"), """

77File.WriteAllText(Path.Combine(tempDir, "app.js"), 97File.WriteAllText(Path.Combine(tempDir, "package.json"),

118File.SetUnixFileMode(bindMountPath, MountFilePermissions); 267File.SetUnixFileMode(bindMountPath, MountFilePermissions); 274File.WriteAllText(Path.Combine(bindMountPath, "01_init.sql"), $""" 366File.WriteAllText(Path.Combine(initFilesPath, "01_init.sql"), $"""

374File.WriteAllText(Path.Combine(bindMountPath, "init.sql"), """ 462File.WriteAllText(Path.Combine(initFilesPath, "init.sql"), """

27if(File.Exists(executablePath)) 37if (File.Exists(executablePath))

272File.WriteAllText(scriptPath, scriptContent); 275File.WriteAllText(requirementsPath, requirementsContent); 279File.WriteAllText(dockerFilePath,

467File.SetUnixFileMode(bindMountPath, MountFilePermissions);

169File.SetUnixFileMode(bindMountPath, BindMountPermissions);

353if (!File.Exists(launchSettingsFilePath)) 358using var stream = File.OpenRead(launchSettingsFilePath);

50Assert.True(File.Exists(testProjectAssemblyPath), $"TestProject.AppHost.dll not found at {testProjectAssemblyPath}.");

13while (directory != null && !Directory.Exists(Path.Combine(directory, ".git")) && !File.Exists(Path.Combine(directory, ".git")))

67Assert.True(File.Exists(filePath)); 68Assert.Equal("Test content", File.ReadAllText(filePath)); 78File.WriteAllText(tempFilename, "Test content"); 81Assert.True(File.Exists(filePath)); 82Assert.Equal("Test content", File.ReadAllText(filePath)); 86File.Delete(tempFilename); 110File.WriteAllText(filePath, "updated"); 114var content2 = File.ReadAllText(filePath2);

25File.WriteAllText(Path.Combine(libraryDirectory, "Library.csproj"), """ 36File.WriteAllText(Path.Combine(libraryDirectory, "Class1.cs"), """ 47File.WriteAllText(Path.Combine(appHostDirectory, "AppHost.csproj"), $""" 73File.WriteAllText(Path.Combine(appHostDirectory, "AppHost.cs"), """ 78File.WriteAllText(Path.Combine(appHostDirectory, "Directory.Build.props"), $""" 87File.WriteAllText(Path.Combine(appHostDirectory, "Directory.Build.targets"), $"""

51await File.WriteAllTextAsync(projectFilePath, csProjContent).DefaultTimeout(); 54await File.WriteAllTextAsync(launchSettingsFilePath, launchSettingsContent).DefaultTimeout();

271File.WriteAllText(Path.Join(tempDir.Path, "Dockerfile"), "this does not matter");

53File.WriteAllText(tempDockerfilePath, "does not need to be valid dockerfile content here"); 65File.WriteAllText(tempDockerfilePath, "does not need to be valid dockerfile content here"); 83File.WriteAllText(tempDockerfilePath, "does not need to be valid dockerfile content here"); 114File.WriteAllText(tempDockerfilePath, "does not need to be valid dockerfile content here");

78if (File.Exists(userSecretsPath)) 80File.Delete(userSecretsPath);

54if (File.Exists(userSecretsPath)) 56File.Delete(userSecretsPath); 65File.WriteAllText(userSecretsPath, secretsFileContents, Encoding.UTF8); 100if (File.Exists(userSecretsPath)) 102File.Delete(userSecretsPath);

53await File.WriteAllTextAsync(tempDockerfilePath, dockerfileContent);

13while (directory != null && !Directory.Exists(Path.Combine(directory, ".git")) && !File.Exists(Path.Combine(directory, ".git")))

66return await File.ReadAllTextAsync(_configFilePath, ct).ConfigureAwait(false);

278Assert.True(File.Exists(composeFile), "Docker Compose file was not created."); 280var content = await File.ReadAllTextAsync(composeFile);

10public static string? FindFullPathFromPath(string command) => FindFullPathFromPath(command, Environment.GetEnvironmentVariable("PATH"), Path.PathSeparator, File.Exists);

49if (!File.Exists(rgp))

30var newContents = AppHostPackageReferenceRegex().Replace(File.ReadAllText(projectPath), @"$1""8.1.0"""); 32File.WriteAllText(projectPath, newContents);

68var projectContents = File.ReadAllText(projectName); 72File.WriteAllText( 94File.WriteAllText(cpmFilePath, cpmContent); 168var projectContents = File.ReadAllText(projectName); 172File.WriteAllText(projectName, modifiedContents);

75Assert.True(File.Exists(testProjectPath), $"Expected tests project file at {testProjectPath}"); 104var newContents = File.ReadAllText(projectPath) 106File.WriteAllText(projectPath, newContents); 124foreach (var line in File.ReadAllLines(testCsPath)) 142File.WriteAllText(testCsPath, sb.ToString());

20if (!string.IsNullOrEmpty(browserPath) && !File.Exists(browserPath)) 31if (File.Exists(probePath))

14if (Directory.Exists(Path.Combine(repoRoot.FullName, ".git")) || File.Exists(Path.Combine(repoRoot.FullName, ".git")))

65File.WriteAllText(Path.Combine(dir, "Directory.Build.props"), "<Project />"); 66File.WriteAllText(Path.Combine(dir, "Directory.Build.targets"), "<Project />"); 73File.Copy(srcNuGetConfigPath, targetNuGetConfigPath); 107File.WriteAllText(Path.Combine(rootDir, "Directory.Build.props"), "<Project />"); 108File.WriteAllText(Path.Combine(rootDir, "Directory.Build.targets"), "<Project />"); 131var csprojContent = File.ReadAllText(csprojPath); 151File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "EndPointWriterHook_cs"), Path.Combine(project.AppHostProjectDirectory, "EndPointWriterHook.cs")); 153string programCs = File.ReadAllText(programCsPath); 156File.WriteAllText(programCsPath, programCs);

105.FirstOrDefault(File.Exists); 128.FirstOrDefault(File.Exists);

18public string CustomHiveDirectory => File.Exists(_stampFilePath) 37if (BuildEnvironment.IsRunningOnCI && File.Exists(_stampFilePath)) 51if (File.Exists(_stampFilePath)) 80File.WriteAllText(_stampFilePath, "");

10public static string? FindFullPathFromPath(string command) => FindFullPathFromPath(command, Environment.GetEnvironmentVariable("PATH"), Path.PathSeparator, File.Exists);

148using var openStream = File.OpenRead(hotelsJson);

30name = !File.Exists(name) ? Path.ChangeExtension(applicationPath, ".StaticWebAssets.xml") : name;

61using (var outfile = new StreamWriter(File.Open(outfilename, FileMode.Create), Encoding.UTF8))

69File.WriteAllText(filepath, datatable); 82File.WriteAllText(filepath, descriptionMap);

96var publishDataRoot = JObject.Parse(File.ReadAllText(publishDataPath)); 328using var stream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);

37if (!File.Exists(OptProfFile)) 42var content = File.ReadAllText(OptProfFile); 66if (!File.Exists(vsixFullPath)) 101using (var archive = new ZipArchive(File.Open(vsixFullPath, FileMode.Open), ZipArchiveMode.Read))

88while (dir != null && !File.Exists(Path.Combine(dir, "global.json")))

157var originalBytes = File.ReadAllBytes(assemblyInfo.FilePath); 219File.WriteAllText(Path.Combine(debugPath, "error.txt"), MiscErrorMessage); 295File.WriteAllText(Path.Combine(debugPath, scriptName), $@"code --diff (Join-Path $PSScriptRoot ""{originalFilePath}"") (Join-Path $PSScriptRoot ""{rebuildFilePath}"")"); 306using var file = File.OpenWrite(sourceFilePath); 325File.WriteAllBytes(assemblyFilePath, buildInfo.AssemblyBytes); 345using var pdbXmlStream = File.Create(buildDataFiles.PdbXmlFilePath); 366using var tempFile = File.OpenWrite(filePath);

130File.OpenRead(assemblyInfo.FilePath),

37if (File.Exists(onDiskPath)) 48using var fileStream = File.OpenRead(onDiskPath);

314using var originalPeReader = new PEReader(File.OpenRead(assemblyInfo.FilePath)); 319filePath => File.Exists(filePath) ? new MemoryStream(File.ReadAllBytes(filePath)) : null,

17using var stream = File.OpenRead(filePath);

42if (!File.Exists(path))

78if (File.Exists(candidateDotNetExePath))

63var existingContent = File.Exists(path) ? File.ReadAllText(path) : ""; 66File.WriteAllText(path, content);

92File.WriteAllText(configFilePath, text); 206File.WriteAllText(fileWithPath, fileContents);

41File.WriteAllText(outputFile, schema);

42private static readonly SyntaxTree s_attributesSyntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText("ConfigurationSchemaAttributes.cs")); 1602var actual = File.ReadAllText(outputPath).ReplaceLineEndings(); 1603var baseline = File.ReadAllText(Path.Combine("Baselines", "IntegrationTest.baseline.json")).ReplaceLineEndings();

90!string.IsNullOrEmpty(diaSymReaderPath) && File.Exists(diaSymReaderPath);

342return File.Exists(_crossgenTool.ToolPath) && File.Exists(_crossgenTool.ClrJitPath); 370if (!File.Exists(_crossgen2Tool.ClrJitPath)) 377return File.Exists(_crossgen2Tool.ToolPath);

104if (!File.Exists(Crossgen2Tool.ItemSpec)) 110if (!string.IsNullOrEmpty(hostPath) && !File.Exists(hostPath)) 118if (!File.Exists(jitPath)) 152if (!File.Exists(CrossgenTool.ItemSpec)) 157if (!File.Exists(CrossgenTool.GetMetadata(MetadataKeys.JitPath))) 170if (!string.IsNullOrEmpty(DiaSymReader) && !File.Exists(DiaSymReader)) 182if (!File.Exists(_outputR2RImage)) 195if (!File.Exists(_inputAssembly))

437if (!File.Exists(processFilePath)) 458if (!File.Exists(serverInfo.processFilePath)) 720if (!File.Exists(FilePath)) 750File.Delete(FilePath);

64if (File.Exists(filePath))

42foreach (var line in File.ReadAllLines(inputPath).Select(l => l.Trim())) 135File.WriteAllText(outputPath, outputText.ToString(), Encoding.UTF8);

30if (!File.Exists(inputFile)) 100using var outFile = new StreamWriter(File.Open(outputMainFile, FileMode.Create), Encoding.UTF8); 171using var outFile = new StreamWriter(File.Open(outputFile, FileMode.Create), Encoding.UTF8);

437if (!File.Exists(certificatePath)) 638File.Move(tempFilename, path, overwrite: true); 641File.WriteAllBytes(path, bytes); 666File.Move(tempFilename, keyPath, overwrite: true); 669File.WriteAllBytes(keyPath, pemEnvelope);

120File.Delete(tmpFile); 131return File.Exists(GetCertificateFilePath(candidate)) ? 173File.Delete(tmpFile); 205File.WriteAllBytes(certificatePath, certBytes); 228File.Delete(certificatePath); 323File.WriteAllBytes(GetCertificateFilePath(certificate), certBytes); 343File.WriteAllBytes(certificatePath, certBytes); 464if (File.Exists(certificatePath)) 466File.Delete(certificatePath);

95if (File.Exists(certPath)) 227if (File.Exists(certPath)) 388if (File.Exists(certPath)) 525if (File.Exists(Path.Combine(searchFolder, command))) 677File.Delete(certPath); 912if (!File.Exists(linkPath)) 915File.CreateSymbolicLink(linkPath, cert.Name);

78if (File.Exists(candidateDotNetExePath))

66File.Copy(executableSource, executable, overwrite: true); 69if (File.Exists(configPath)) 71File.Copy(configPath, executable + ".config", overwrite: true); 94if (!string.IsNullOrEmpty(projectAssetsFile) && File.Exists(projectAssetsFile)) 96using var reader = new JsonTextReader(File.OpenText(projectAssetsFile)); 110if (File.Exists(runtimeConfigPath)) 168File.Delete(executable); 176File.Delete(executable + ".config");

78if (File.Exists(candidateDotNetExePath))

54return File.Exists(GetFullPath(file));

102if (!File.Exists(project)) 137return File.Exists(Path.GetFullPath(file)) && file.EndsWith(".csproj", StringComparison.Ordinal); 350if (!File.Exists(filePath)) 515var destinationExists = File.Exists(destinationPath); 531using (var destinationStream = File.OpenRead(destinationPath)) 575File.Delete(destinationPath);

44File.Delete(GetFullPath(file));

78if (File.Exists(candidateDotNetExePath))

44File.WriteAllText(result.FilePath, result.GeneratedCode); 195var cshtmlContent = File.ReadAllText(_source.PhysicalPath); 214var includeFileContent = File.ReadAllText(System.IO.Path.Combine(basePath, includeFileName));

78if (File.Exists(candidateDotNetExePath))

209if (File.Exists(potentialPath))

70if (File.Exists(codePath)) 72File.Delete(codePath); 75using (FileStream fs = File.Create(codePath)) 90if (!success && toDeleteFile && File.Exists(codePath)) 92File.Delete(codePath); 100if (File.Exists(sgenSource)) 101File.Delete(sgenSource); 111File.Copy(codePath, sourceFilePath, true);

22Assert.False(File.Exists(outputFile)); 25if (File.Exists(smassemblypath)) 28Assert.True(File.Exists(outputFile)); 29File.Delete(outputFile);

171File.WriteAllText(programFilePath, s_programClass);

79if (File.Exists(_outputFilePath)) 81File.Delete(_outputFilePath);

439if (!IsUpdateOperation && this.ToolContext <= OperationalContext.Global && File.Exists(filePath)) 526if (!PathHelper.IsUnderDirectory(svcutilParmasFile, projectDirInfo, out paramsFilePath, out fileRelPath) || !File.Exists(paramsFilePath)) 529if (!PathHelper.IsUnderDirectory(wcfcsParamsFile, projectDirInfo, out paramsFilePath, out fileRelPath) || !File.Exists(paramsFilePath)) 700if (File.Exists(projectFullPath))

121using (Stream str = File.OpenRead(fileName)) { } 215using (Stream str = File.OpenRead(fileName)) { }

292File.Delete(fileName);

3938File.Delete(options.OutputAssembly); 3954using (FileStream stream = File.Open(file, FileMode.Open, FileAccess.Read, share)) 4055using (Stream str = File.OpenRead(fileName)) { } 4125using (Stream str = File.OpenRead(fileName)) { }

1895} while (File.Exists(dumpFileName));

1050public AutoGenWriter(string fileName, string regionName) : this(File.Open(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite), regionName)

376StreamReader reader = new StreamReader(File.OpenRead(fileName), detectEncodingFromByteOrderMarks: true); 435StreamWriter writer = new StreamWriter(File.OpenWrite(fileName));

527if (!File.Exists(fullFileName)) 535if (!File.Exists(fullFileName) && !string.IsNullOrWhiteSpace(specNamespace)) 544if (!File.Exists(fullFileName) && !Path.IsPathRooted(schemaLocation)) 548if (!File.Exists(fullFileName)) 555if (File.Exists(fullFileName))

71var fileInfo = this.MetadataFiles.FirstOrDefault(fi => File.Exists(fi.FilePath));

183if (File.Exists(filePath))

147var project = await ParseAsync(File.ReadAllText(filePath), filePath, logger, cancellationToken).ConfigureAwait(false); 154var project = await ParseAsync(File.ReadAllText(filePath), filePath, logger, cancellationToken, tfMoniker).ConfigureAwait(false); 322if (fullPath == null || !File.Exists(fullPath)) 396if (File.Exists(fullPath)) 412project = await ParseAsync(File.ReadAllText(fullPath), fullPath, logger, cancellationToken).ConfigureAwait(false); 701using (StreamWriter writer = File.CreateText(this.FullPath)) 798if (File.Exists(assetsFile) && !(this.TargetFramework.Contains("-") && !this.TargetFramework.ToLower().Contains("windows"))) 883if (File.Exists(depsFile)) 890using (var stream = File.OpenRead(depsFile)) 915if (File.Exists(dependency.FullPath) && !assemblyDependencies.Contains(dependency))

140jsonText = File.ReadAllText(fileInfo.FullName); 173File.WriteAllText(filePath, this.Json);

149while (dotnetDir != null && !(File.Exists(Path.Combine(dotnetDir, "dotnet")) || File.Exists(Path.Combine(dotnetDir, "dotnet.exe"))))

209if (File.Exists(filePath)) 216File.Copy(filePath, dstFilePath, overwrite: true);

47if (!File.Exists(Path.Combine(destinationDirectory, "global.json"))) 53if (!File.Exists(Path.Combine(destinationDirectory, "nuget.config"))) 73if (File.Exists(nugetConfigPath)) 79using (var stream = File.Open(nugetConfigPath, FileMode.Open, FileAccess.ReadWrite))

145if (!File.Exists(options.OutputFile.FullName))

174if (!File.Exists(wsdlFile)) 180Assert.True(File.Exists(wsdlFile), $"{wsdlFile} not initialized!"); 226if (!File.Exists(assemblyPath)) 238Assert.True(File.Exists(binProjPath), $"{nameof(binProjPath)} not initialized!"); 239Assert.True(File.Exists(libProjPath), $"{nameof(libProjPath)} not initialized!"); 369Assert.True(File.Exists(srcParamsFilePath), $"{nameof(srcParamsFilePath)} not initialized!"); 374File.Copy(f, Path.Combine(this_TestCaseProject.DirectoryPath, Path.GetFileName(f))); 383File.WriteAllText(dstParamsFile, File.ReadAllText(dstParamsFile).Replace("$testCasesPath$", g_TestCasesDir.Replace("\\", "/")));

107var originalText = System.IO.File.ReadAllText(fileName); 112System.IO.File.WriteAllText(fileName, updatedText);

99File.Copy(Path.Combine(g_TestCasesDir, "FullFramework", "FullFramework.cs"), Path.Combine(this_TestCaseOutputDir, "FullFramework.cs"), true); 100File.Copy(Path.Combine(g_TestCasesDir, "FullFramework", "FullFramework.csproj"), Path.Combine(this_TestCaseOutputDir, "FullFramework.csproj"), true); 127File.Copy(Path.Combine(g_TestCasesDir, this_TestCaseName, testCaseName, "Program.cs"), Path.Combine(this_TestCaseOutputDir, "Program.cs"), true); 128File.Copy(Path.Combine(g_TestCasesDir, this_TestCaseName, testCaseName, $"{testCaseName}.csproj"), Path.Combine(this_TestCaseOutputDir, $"{testCaseName}.csproj"), true);

28if (forceNew && File.Exists(filePath)) 30File.Delete(filePath); 31if (File.Exists(dstProgramFile)) 32File.Delete(dstProgramFile); 36if (File.Exists(filePath)) 51File.Move(srcProgramFile, dstProgramFile); 87Assert.True(File.Exists(project?.FullPath), $"{nameof(project)} is not initialized!"); 175Assert.True(File.Exists(project?.FullPath), $"{nameof(project)} is not initialized!"); 181File.Copy(srcParamsFile, dstParamsFile);

60File.WriteAllText(Path.Combine(g_TestOutputDir, "Directory.Build.props"), "<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\" />"); 61File.WriteAllText(Path.Combine(g_TestOutputDir, "Directory.Build.targets"), "<Project></Project>"); 95if (!File.Exists(filePath)) 115File.Copy(project.FullPath, projectPath); 116File.Copy(srcProgramPath, programPath); 118File.WriteAllText(programPath, File.ReadAllText(programPath) 167Assert.True(File.Exists(g_StarterProject.FullPath), $"{nameof(g_StarterProject)} is not initialized!"); 173File.WriteAllText(Path.Combine(g_TestOutputDir, "Directory.Build.props"), "<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\" />"); 174File.WriteAllText(Path.Combine(g_TestOutputDir, "Directory.Build.targets"), "<Project></Project>"); 268if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && File.Exists(Path.Combine(linuxBaselinePath, Path.GetFileName(this_TestCaseLogFile)))) 335File.WriteAllText(this.this_TestCaseLogFile, logText); 354if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && File.Exists(Path.Combine(linuxBaselinePath, Path.GetFileName(this_TestCaseLogFile)))) 430File.Copy(generated, expected); 458File.WriteAllText(scriptPath, cmdStr.ToString()); 472fileLines1.AddRange(File.ReadAllLines(baselineFile)); 473fileLines2.AddRange(File.ReadAllLines(generatedFile)); 590Assert.True(rootSolutionFolder != null && File.Exists(rootSolutionFolder), $"Unable to find dotnet-svcutil.sln file, current dir: {parentDir}"); 606File.WriteAllText(Path.Combine(directory, "global.json"), globalConfig); 624File.WriteAllText(Path.Combine(g_TestOutputDir, "nuget.config"), nugetConfigText.Replace("$svcutilTestFeed$", g_SvcutilNugetFeed));

225File.Copy(Path.Combine(g_TestCasesDir, "wsdl", "Simple.wsdl"), Path.Combine(this_TestGroupOutputDir, "wsdl", "Simple.wsdl")); 271File.WriteAllText(this_TestCaseLogFile, this_FixupUtil.ReplaceText(log)); 309File.WriteAllText(this_TestCaseLogFile, this_FixupUtil.ReplaceText(log)); 331File.Copy(jsonFileSrcPath, jsonFileDstPath); 332File.WriteAllText(jsonFileDstPath, File.ReadAllText(jsonFileDstPath).Replace("$testCaseProject$", this_TestCaseProject.FullPath.Replace("\\", "/"))); 348var jsonText = File.ReadAllText(jsonFileSrcPath); 354File.WriteAllText(outJsonFile, options.Json);

58else if (!File.Exists(Path.Combine(Path.GetDirectoryName(projectPath), appsettingsFile))) 77if (File.Exists(launchSettingsFilePath))

28if (File.Exists(_filePath)) 46File.Move(tempFilename, _filePath, overwrite: true);

66if (File.Exists(secretsFilePath))

78if (File.Exists(candidateDotNetExePath))

47if (!File.Exists(projectPath))

113if (!File.Exists(outputFile)) 119var id = File.ReadAllText(outputFile)?.Trim(); 144var targetPath = searchPaths.Select(p => Path.Combine(p, "SecretManager.targets")).FirstOrDefault(File.Exists); 157if (File.Exists(file)) 159File.Delete(file);

86File.Move(tempFilename, _secretsFilePath, overwrite: true); 89File.WriteAllText(_secretsFilePath, contents.ToString(), Encoding.UTF8);

78if (File.Exists(candidateDotNetExePath))

47if (!File.Exists(projectPath))

113if (!File.Exists(outputFile)) 119var id = File.ReadAllText(outputFile)?.Trim(); 144var targetPath = searchPaths.Select(p => Path.Combine(p, "SecretManager.targets")).FirstOrDefault(File.Exists); 157if (File.Exists(file)) 159File.Delete(file);

59var fileInfo = System.IO.File.CreateSymbolicLink(symlink, path);

159if (File.Exists(resourceAssemblyFullPath)) 192if (File.Exists(fileWithPath)) 269if (File.Exists(fileWithPath)) 278if (File.Exists(fileWithPath)) 287if (File.Exists(fileWithPath)) 298File.WriteAllText(nuspecFile, result.ToString());

275if (!File.Exists(path)) 436File.WriteAllText(fileWithPath, fileContents); 457File.WriteAllText(fileWithPath, fileContents); 610File.WriteAllText(fileWithPath, builder.ToString()); 787actualContent = File.ReadAllLines(fileWithPath); 834File.WriteAllText(fileWithPath, builder.ToString()); 873if (!File.Exists(assemblyPath)) 906var shippedFileExists = File.Exists(shippedFile); 907var unshippedFileExists = File.Exists(unshippedFile); 930using var fileStream = File.OpenRead(shippedFile); 940using var fileStreamUnshipped = File.OpenRead(unshippedFile); 1113File.WriteAllText(rulesetFilePath, text); 1178File.WriteAllText(editorconfigFilePath, text); 1363string actual = File.ReadAllText(fileWithPath); 1400File.WriteAllText(configFilePath, text); 1611File.WriteAllText(fileWithPath, fileContents);

399return File.GetLastWriteTimeUtc(fullPath);

51return File.Exists(fullPath);

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

66if (File.Exists(potentialAssemblyPath))

53actualContent = File.ReadAllLines(fileWithPath); 100File.WriteAllText(fileWithPath, builder.ToString()); 148if (!File.Exists(path))

94if (!File.Exists(assemblyPath))

309var stream = File.Create(_context.FileListPath); 384using var outStream = File.Create(filePath); 389File.Delete(filePath);

78if (File.Exists(candidateDotNetExePath))

62if (!File.Exists($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump") && 63!File.Exists($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump.exe"))

62if (!File.Exists("xunit.runner.json")) 64File.Copy("default.runner.json", "xunit.runner.json"); 130File.Move(filename, backupFilename); 165File.Move(backupFilename, filename); 292if (File.Exists("TestResults/TestResults.xml")) 295File.Copy("TestResults/TestResults.xml", "testResults.xml", overwrite: true); 317File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, logName)); 331File.Copy(file, Path.Combine(HELIX_WORKITEM_UPLOAD_ROOT, fileName));

41var text = File.ReadAllText(path); 54var text = File.ReadAllText(path);

38if (!File.Exists(solutionPath))

57if (!File.Exists(solutionPath))

39if (!File.Exists(_solutionPath))

56if (!File.Exists(solutionPath))

32if (!File.Exists(csFilePath)) 38var text = File.ReadAllText(csFilePath).Replace("<auto-generated />", "")

38if (!File.Exists(_solutionPath))

59if (!File.Exists(_solutionPath))

60if (!File.Exists(_solutionPath))

30if (!File.Exists(_csFilePath)) 44.AddDocument(documentId, "DocumentName", File.ReadAllText(_csFilePath));

35if (!File.Exists(csFilePath)) 38var text = File.ReadAllText(csFilePath);

73File.Delete(temporaryFile); 74File.Move(requestHandlerPath, temporaryFile); 83File.Delete(temporaryFile);

217dynamic depsFileContent = JsonConvert.DeserializeObject(File.ReadAllText(path)); 220File.WriteAllText(path, output); 225File.AppendAllText( 234return File.ReadAllText(filename); 267File.WriteAllText(Path.Combine(rootApplicationDirectory.FullName, "web.config"), "<configuration></configuration>");

39File.WriteAllText(Path.Combine(appPath, "app_offline.htm"), content); 45() => File.Delete(Path.Combine(appPath, "app_offline.htm")), 83File.Delete(file);

18deploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.SubApp.Config");

55if (!File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", "w3wp.exe")) && !SkipInVSTSAttribute.RunningInVSTS) 63if (!File.Exists(ancmConfigPath)) 68if (!File.Exists(ancmConfigPath) && !SkipInVSTSAttribute.RunningInVSTS) 95if (File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", module.DllName)) || SkipInVSTSAttribute.RunningInVSTS)

180File.Delete(firstTempFile); 181File.Delete(secondTempFile); 337using (var stream = File.Open(logPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

58await Helpers.Retry(async () => await File.ReadAllTextAsync(Path.Combine(result.ContentRoot, "Started.txt")), TimeoutExtensions.DefaultTimeoutValue); 102await Helpers.Retry(async () => await File.ReadAllTextAsync(Path.Combine(result.ContentRoot, "Started.txt")), TimeoutExtensions.DefaultTimeoutValue);

217dynamic depsFileContent = JsonConvert.DeserializeObject(File.ReadAllText(path)); 220File.WriteAllText(path, output); 225File.AppendAllText( 234return File.ReadAllText(filename); 267File.WriteAllText(Path.Combine(rootApplicationDirectory.FullName, "web.config"), "<configuration></configuration>");

39File.WriteAllText(Path.Combine(appPath, "app_offline.htm"), content); 45() => File.Delete(Path.Combine(appPath, "app_offline.htm")), 83File.Delete(file);

18deploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.SubApp.Config");

55if (!File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", "w3wp.exe")) && !SkipInVSTSAttribute.RunningInVSTS) 63if (!File.Exists(ancmConfigPath)) 68if (!File.Exists(ancmConfigPath) && !SkipInVSTSAttribute.RunningInVSTS) 95if (File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", module.DllName)) || SkipInVSTSAttribute.RunningInVSTS)

107using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 125using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 179File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "Microsoft.AspNetCore.Server.IIS.dll"), "");

214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 280File.Copy( 346File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"), ""); 406File.Delete(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.dll")); 447File.Delete(Path.Combine(deploymentResult.ContentRoot, "aspnetcorev2_inprocess.dll")); 744File.WriteAllBytes(applicationDll, File.ReadAllBytes(applicationDll)); 746File.WriteAllBytes(handlerDll, File.ReadAllBytes(handlerDll));

32ServerConfigTemplateContent = File.ReadAllText("IIS.config"),

217dynamic depsFileContent = JsonConvert.DeserializeObject(File.ReadAllText(path)); 220File.WriteAllText(path, output); 225File.AppendAllText( 234return File.ReadAllText(filename); 267File.WriteAllText(Path.Combine(rootApplicationDirectory.FullName, "web.config"), "<configuration></configuration>");

39File.WriteAllText(Path.Combine(appPath, "app_offline.htm"), content); 45() => File.Delete(Path.Combine(appPath, "app_offline.htm")), 83File.Delete(file);

18deploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.SubApp.Config");

55if (!File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", "w3wp.exe")) && !SkipInVSTSAttribute.RunningInVSTS) 63if (!File.Exists(ancmConfigPath)) 68if (!File.Exists(ancmConfigPath) && !SkipInVSTSAttribute.RunningInVSTS) 95if (File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", module.DllName)) || SkipInVSTSAttribute.RunningInVSTS)

107using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 125using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 179File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "Microsoft.AspNetCore.Server.IIS.dll"), "");

214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 280File.Copy( 346File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"), ""); 406File.Delete(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.dll")); 447File.Delete(Path.Combine(deploymentResult.ContentRoot, "aspnetcorev2_inprocess.dll")); 744File.WriteAllBytes(applicationDll, File.ReadAllBytes(applicationDll)); 746File.WriteAllBytes(handlerDll, File.ReadAllBytes(handlerDll));

217dynamic depsFileContent = JsonConvert.DeserializeObject(File.ReadAllText(path)); 220File.WriteAllText(path, output); 225File.AppendAllText( 234return File.ReadAllText(filename); 267File.WriteAllText(Path.Combine(rootApplicationDirectory.FullName, "web.config"), "<configuration></configuration>");

39File.WriteAllText(Path.Combine(appPath, "app_offline.htm"), content); 45() => File.Delete(Path.Combine(appPath, "app_offline.htm")), 83File.Delete(file);

18deploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.SubApp.Config");

55if (!File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", "w3wp.exe")) && !SkipInVSTSAttribute.RunningInVSTS) 63if (!File.Exists(ancmConfigPath)) 68if (!File.Exists(ancmConfigPath) && !SkipInVSTSAttribute.RunningInVSTS) 95if (File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", module.DllName)) || SkipInVSTSAttribute.RunningInVSTS)

107using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 125using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 179File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "Microsoft.AspNetCore.Server.IIS.dll"), "");

214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 280File.Copy( 346File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"), ""); 406File.Delete(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.dll")); 447File.Delete(Path.Combine(deploymentResult.ContentRoot, "aspnetcorev2_inprocess.dll")); 744File.WriteAllBytes(applicationDll, File.ReadAllBytes(applicationDll)); 746File.WriteAllBytes(handlerDll, File.ReadAllBytes(handlerDll));

132var fileContents = File.ReadAllBytes(dllPath); 133File.WriteAllBytes(dllPath, fileContents); 152File.WriteAllText(Path.Combine(deleteDirPath, "file.dll"), "");

217dynamic depsFileContent = JsonConvert.DeserializeObject(File.ReadAllText(path)); 220File.WriteAllText(path, output); 225File.AppendAllText( 234return File.ReadAllText(filename); 267File.WriteAllText(Path.Combine(rootApplicationDirectory.FullName, "web.config"), "<configuration></configuration>");

39File.WriteAllText(Path.Combine(appPath, "app_offline.htm"), content); 45() => File.Delete(Path.Combine(appPath, "app_offline.htm")), 83File.Delete(file);

18deploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.SubApp.Config");

55if (!File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", "w3wp.exe")) && !SkipInVSTSAttribute.RunningInVSTS) 63if (!File.Exists(ancmConfigPath)) 68if (!File.Exists(ancmConfigPath) && !SkipInVSTSAttribute.RunningInVSTS) 95if (File.Exists(Path.Combine(Environment.SystemDirectory, "inetsrv", module.DllName)) || SkipInVSTSAttribute.RunningInVSTS)

13public bool IsMet { get; } = File.Exists(TestServer.HostableWebCoreLocation);

73File.Delete(temporaryFile); 74File.Move(requestHandlerPath, temporaryFile); 83File.Delete(temporaryFile);

217dynamic depsFileContent = JsonConvert.DeserializeObject(File.ReadAllText(path)); 220File.WriteAllText(path, output); 225File.AppendAllText( 234return File.ReadAllText(filename); 267File.WriteAllText(Path.Combine(rootApplicationDirectory.FullName, "web.config"), "<configuration></configuration>");

39File.WriteAllText(Path.Combine(appPath, "app_offline.htm"), content); 45() => File.Delete(Path.Combine(appPath, "app_offline.htm")), 83File.Delete(file);

18deploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.SubApp.Config");

180File.Delete(firstTempFile); 181File.Delete(secondTempFile); 337using (var stream = File.Open(logPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

107using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 125using (var stream = File.Open(Path.Combine(deploymentResult.ContentRoot, "app_offline.htm"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None)) 179File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "Microsoft.AspNetCore.Server.IIS.dll"), "");

214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 280File.Copy( 346File.WriteAllText(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"), ""); 406File.Delete(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.dll")); 447File.Delete(Path.Combine(deploymentResult.ContentRoot, "aspnetcorev2_inprocess.dll")); 744File.WriteAllBytes(applicationDll, File.ReadAllBytes(applicationDll)); 746File.WriteAllBytes(handlerDll, File.ReadAllBytes(handlerDll));

68using (var w = File.CreateText(Context.AssemblyListFile)) 157using (var fs = File.Open(Path.Combine(Context.OutputDirectory, Context.PInvokesListFile), FileMode.Create)) 171if (File.Exists(target)) 173File.Delete(target); 174File.Delete(target + ".mdb"); 175File.Delete(Path.ChangeExtension(target, "pdb")); 176File.Delete(GetConfigFile(target)); 219if (!File.Exists(satelliteAssembly)) 226File.Copy(satelliteAssembly, Path.Combine(culturePath, resourceFile), true); 233if (!File.Exists(config)) 241File.Copy(config, GetConfigFile(GetAssemblyFileName(assembly, directory)), true); 268File.Copy(source, target, true); 273if (File.Exists(mdb)) 274File.Copy(mdb, target + ".mdb", true); 277if (File.Exists(pdb)) 278File.Copy(pdb, Path.ChangeExtension(target, "pdb"), true);

104if (File.Exists(fileName))

209if (!File.Exists(file))

729if (!File.Exists(xmlFile)) 735inputs.Add(new ResolveFromXmlStep(File.OpenRead(xmlFile), xmlFile)); 743if (!File.Exists(assemblyFile) && assemblyFile.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase)) 992if (File.Exists(assemblyPath)) 1012pipeline.PrependStep(new ResolveFromXmlStep(File.OpenRead(file), file)); 1017pipeline.AddStepBefore(typeof(MarkStep), new LinkAttributesStep(File.OpenRead(file), file)); 1022pipeline.AddStepBefore(typeof(MarkStep), new BodySubstituterStep(File.OpenRead(file), file));

103if (!File.Exists(namespaceFilePath)) 110if (!File.Exists(mscorlibFilePath)) 117if (!File.Exists(cortypeFilePath)) 124if (!File.Exists(rexcepFilePath)) 133if (!File.Exists(iLLinkTrimXmlFilePath)) 154string[] namespaces = File.ReadAllLines(namespaceFile); 187string[] types = File.ReadAllLines(typeFile); 293string[] corTypes = File.ReadAllLines(corTypeFile); 316string[] excTypes = File.ReadAllLines(excTypeFile);

272if (!File.Exists(OSXCustomKeychainFilePath))

27File.WriteAllText(args[1], "");

188File.WriteAllText(System.IO.Path.Combine(hostingEnv.ContentRootPath, "Started.txt"), ""); 959var fileStream = File.OpenWrite(tempFile); 974File.Delete(tempFile); 1115File.Delete(context.Request.Headers["ANCMRHPath"]);

136using (var manifestWriter = File.CreateText(PlatformManifestFile)) 167if (File.Exists(filePath))

34if (!File.Exists(TemplatePath)) 40string templateContent = File.ReadAllText(TemplatePath);

85using (var depsFileStream = File.Create(Path.Combine(SharedFrameworkDirectory, $"{sharedFxName}.deps.json"))) 98using (var peReader = new PEReader(File.OpenRead(file)))

54string[] readmeLines = File.ReadAllLines(ReadmeFile); 98File.WriteAllLines(

129TpnDocument existingTpn = TpnDocument.Parse(File.ReadAllLines(TpnFile)); 184File.WriteAllText(TpnFile, newTpn.ToString());

48while (dir != null && !File.Exists(Path.Combine(dir, "dotnet.exe")))

378File.WriteAllBytes(c.Path, [1, 2, 3]);

267var results = File.ReadAllText(tempFile); 268File.Delete(tempFile);

437File.WriteAllBytes(path, bytes);

163var pem = File.ReadAllText("Certs/ca.pem"); 859var jobject = JObject.Parse(File.ReadAllText(keyFile));

107using (_writer = new StreamWriter(File.Open(outFileName, FileMode.Create), Encoding.UTF8)) 161using (_writer = new StreamWriter(File.Open(Path.Combine(_location, "OperationKind.Generated.cs"), FileMode.Create), Encoding.UTF8))

113if (!File.Exists(value)) 129if (!File.Exists(value))

399return File.GetLastWriteTimeUtc(fullPath);

51return File.Exists(fullPath);

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

399return File.GetLastWriteTimeUtc(fullPath);

51return File.Exists(fullPath);

113if (!File.Exists(value)) 129if (!File.Exists(value))

38File.WriteAllText(editorconfigFilePath, GetEditorconfig(rulesetFilePath)); 96using Stream stream = File.OpenRead(rulesetFilePath);

26public override SourceText? GetText(CancellationToken cancellationToken = default) => SourceText.From(File.ReadAllText(Path));

26public override SourceText? GetText(CancellationToken cancellationToken = default) => SourceText.From(File.ReadAllText(Path));

64if (File.Exists(executable + ".exe")) 76if (File.Exists(candidate))

17public bool FileExists(string path) => File.Exists(path); 19public void DeleteFile(string path) => File.Delete(path); 39File.WriteAllText(path, content); 42public virtual void CopyFile(string sourceFileName, string destFileName, bool overwrite = false) => File.Copy(sourceFileName, destFileName, overwrite); 46public FileAttributes GetAttributes(string path) => File.GetAttributes(path);

31using Stream stream = File.OpenRead(path);

29bool archiveExists = File.Exists(archivePath); 32using FileStream fs = File.OpenWrite(archivePath);

195if (File.Exists(dll)) 202if (File.Exists(dll))

20if (!File.Exists(path)) 28if (File.Exists(path))

96using var fileStream = File.OpenRead(assembly); 126using var fileStream = File.OpenRead(assembly);

93var runtimeConfig = JObject.Parse(File.ReadAllText(runtimeConfigFilePath)); 113var depsFile = JObject.Parse(File.ReadAllText(depsFilePath)); 187using var fileStream = File.OpenRead(path); 234using var fileStream = File.OpenRead(path); 252var lines = File.ReadAllLines(versionFile);

84using var fileStream = File.OpenRead(path); 118using var fileStream = File.OpenRead(path); 139var packageOverrideFileLines = File.ReadAllLines(packageOverridePath); 201using var fileStream = File.OpenRead(path); 240_output.WriteLine(File.ReadAllText(platformManifestPath)); 246var manifestFileLines = File.ReadAllLines(platformManifestPath);

59using (var stream = File.OpenRead(Path.Combine("TestContent", $"{name}.txt"))) 98File.WriteAllText(Path.Combine(Root, filename), contents);

73File.WriteAllText( 77File.WriteAllText(Path.Combine(projectPath.FullName, "Properties", "launchSettings.json"), 80File.WriteAllText( 84File.WriteAllText(

67Assert.Contains("dotnet-user-jwts", File.ReadAllText(appsettings)); 112var appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 115appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 129var appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 132appSettings = JsonSerializer.Deserialize<JsonObject>(File.ReadAllText(appsettings)); 206var appsettingsContent = File.ReadAllText(appsettings); 224var appsettingsContent = File.ReadAllText(appsettings); 242var appsettingsContent = File.ReadAllText(appsettings); 260var appsettingsContent = File.ReadAllText(appsettings); 285await File.WriteAllTextAsync(secretsFilePath, 299using var openStream = File.OpenRead(secretsFilePath); 493File.Delete(launchSettingsPath); 507await File.WriteAllTextAsync(secretsFilePath, 518using var openStream = File.OpenRead(secretsFilePath); 534await File.WriteAllTextAsync(secretsFilePath, 546using var openStream = File.OpenRead(secretsFilePath); 585using var openStream = File.OpenRead(secretsFilePath); 607using var openStream = File.OpenRead(secretsFilePath); 629using var openStream = File.OpenRead(secretsFilePath); 863Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(app.UserJwtsFilePath));

250kvps.Add(new KeyValuePair<string, string>("wresult", File.ReadAllText(tokenFile))); 452var metadata = File.ReadAllText(@"WsFederation/federationmetadata.xml");

248kvps.Add(new KeyValuePair<string, string>("wresult", File.ReadAllText(tokenFile))); 448var metadata = File.ReadAllText(@"WsFederation/federationmetadata.xml");

84var transformFile = File.ReadAllText("applicationHost.xdt");

22if (!File.Exists(filePath)) 27var fileContent = File.ReadAllText(filePath);

22if (!File.Exists(filePath)) 27var fileContent = File.ReadAllText(filePath);

187if (File.Exists(configFile)) 189var appSettingsJson = File.ReadAllBytes(configFile);

130if (!File.Exists(debugProxyPath))

78if (File.Exists(candidateDotNetExePath))

282if (File.Exists(manifestPath)) 284using var manifestStream = File.OpenRead(manifestPath);

34if (!File.Exists(mountsFile)) 39var lines = File.ReadAllLines(mountsFile); 99if (!File.Exists(procFile)) 104var lines = File.ReadAllLines(procFile);

111using (var fileStream = File.OpenRead(fullPath)) 147File.Move(tempTempFilename, tempFilename); 152using (var tempFileStream = File.OpenWrite(tempFilename)) 164File.Move(tempFilename, finalFilename); 170File.Copy(tempFilename, finalFilename); 175File.Delete(tempFilename); // won't throw if the file doesn't exist

41string fileText = File.ReadAllText(allFiles[0].FullName); 76var fileText = File.ReadAllText(file.FullName); 110string fileText = File.ReadAllText(allFiles[0].FullName); 156string fileText = File.ReadAllText(allFiles[0].FullName); 236string fileText = File.ReadAllText(allFiles[0].FullName); 307string fileText = File.ReadAllText(allFiles[0].FullName);

82var parsedElement = XElement.Parse(File.ReadAllText(fileInfo.FullName)); 116var parsedElement = XElement.Parse(File.ReadAllText(fileInfo.FullName)); 209Assert.True(File.Exists(filePath1)); 210Assert.True(File.Exists(filePath2)); 211Assert.True(File.Exists(filePath3)); 240Assert.True(File.Exists(filePath1)); // Deletion not attempted after failure 241Assert.True(File.Exists(filePath2)); // Deletion fails because of lock 242Assert.False(File.Exists(filePath3)); // Deleted before error 256Assert.True(File.Exists(filePath)); 265File.Delete(filePath); 273Assert.False(File.Exists(filePath));

437if (!File.Exists(certificatePath)) 638File.Move(tempFilename, path, overwrite: true); 641File.WriteAllBytes(path, bytes); 666File.Move(tempFilename, keyPath, overwrite: true); 669File.WriteAllBytes(keyPath, pemEnvelope);

120File.Delete(tmpFile); 131return File.Exists(GetCertificateFilePath(candidate)) ? 173File.Delete(tmpFile); 205File.WriteAllBytes(certificatePath, certBytes); 228File.Delete(certificatePath); 323File.WriteAllBytes(GetCertificateFilePath(certificate), certBytes); 343File.WriteAllBytes(certificatePath, certBytes); 464if (File.Exists(certificatePath)) 466File.Delete(certificatePath);

95if (File.Exists(certPath)) 227if (File.Exists(certPath)) 388if (File.Exists(certPath)) 525if (File.Exists(Path.Combine(searchFolder, command))) 677File.Delete(certPath); 912if (!File.Exists(linkPath)) 915File.CreateSymbolicLink(linkPath, cert.Name);

50Assert.True(File.Exists(CertificateName)); 52var exportedCertificate = new X509Certificate2(File.ReadAllBytes(CertificateName)); 149Assert.True(File.Exists(CertificateName)); 151var exportedCertificate = new X509Certificate2(File.ReadAllBytes(CertificateName), certificatePassword); 183Assert.True(File.Exists(CertificateName)); 216Assert.True(File.Exists(CertificateName)); 314File.WriteAllBytes(CertificateName, wrongSubjectCertificate.Export(X509ContentType.Pfx, certificatePassword)); 345Assert.True(File.Exists(CertificateName)); 538Assert.True(File.Exists(CertificateName)); 539Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(CertificateName)); 541Assert.True(File.Exists(KeyName)); 542Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(KeyName));

110if (File.Exists(stackFrame.File)) 112lines = File.ReadLines(stackFrame.File); 124lines = File.ReadLines(fileInfo.PhysicalPath);

21await File.WriteAllTextAsync(Path.Combine(contentRootPath, "appsettings.json"), @" 64await File.WriteAllTextAsync(Path.Combine(contentRootPath, "appsettings.Development.json"), @" 107await File.WriteAllTextAsync(Path.Combine(contentRootPath, "appsettings.json"), @" 143await File.WriteAllTextAsync(Path.Combine(contentRootPath, "appsettings.json"), @"

113File.WriteAllText("appsettings.json", @" 145File.Delete("appsettings.json");

67using (var xmlComments = File.OpenText($"{typeof(GreeterService).Assembly.GetName().Name}.xml"))

110if (File.Exists(stackFrame.File)) 112lines = File.ReadLines(stackFrame.File); 124lines = File.ReadLines(fileInfo.PhysicalPath);

51if (candidate != null && File.Exists(candidate)) 53return File.OpenRead(candidate);

91var compiledTemplate = generator.CompileTemplate(File.ReadAllText(templatePath)); 94var currentContent = File.ReadAllText(currentContentPath);

369await File.WriteAllTextAsync(baselineFilePath, newSource); 373var baseline = await File.ReadAllTextAsync(baselineFilePath); 423if (File.Exists(dll)) 431if (File.Exists(dll))

369await File.WriteAllTextAsync(baselineFilePath, newSource); 373var baseline = await File.ReadAllTextAsync(baselineFilePath); 423if (File.Exists(dll)) 431if (File.Exists(dll))

17var compiledTemplate = generator.CompileTemplate(File.ReadAllText(templatePath)); 20var currentContent = File.ReadAllText(currentContentPath);

35var currentResultsOfTGenerated = File.ReadAllText(resultsOfTGeneratedPath); 36var currentTestsGenerated = File.ReadAllText(testsGeneratedPath); 40var testResultsOfTGenerated = File.ReadAllText(testResultsOfTGeneratedPath); 41var testTestsGenerated = File.ReadAllText(testTestsGeneratedPath); 48File.Delete(testResultsOfTGeneratedPath); 49File.Delete(testTestsGeneratedPath);

273return File.AppendText(fileName);

51Assert.True(File.Exists(filePath)); 53Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(filePath)); 98Assert.True(File.Exists(filePathToday)); 99Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(filePathToday)); 100Assert.True(File.Exists(filePathTomorrow)); 101Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(filePathTomorrow)); 137Assert.True(File.Exists(filePath1)); 138Assert.True(File.Exists(filePath2)); 140Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(filePath1)); 141Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(filePath2)); 154File.WriteAllText(Path.Combine(path, "randomFile.txt"), "Text"); 400Assert.True(File.Exists(filePath1)); 401Assert.True(File.Exists(filePath2)); 402Assert.True(File.Exists(filePath3)); 404Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(filePath1)); 405Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(filePath2)); 406Assert.Equal(_messageThree + Environment.NewLine, File.ReadAllText(filePath3)); 466Assert.False(File.Exists(filePath1)); 467Assert.False(File.Exists(filePath2)); 468Assert.True(File.Exists(filePath3)); 469Assert.True(File.Exists(filePath4)); 471Assert.Equal(_messageThree + Environment.NewLine, File.ReadAllText(filePath3)); 472Assert.Equal(_messageFour + Environment.NewLine, File.ReadAllText(filePath4)); 536Assert.True(File.Exists(filePath1)); 537Assert.True(File.Exists(filePath2)); 539Assert.Equal(_messageOne + Environment.NewLine, File.ReadAllText(filePath1)); 540Assert.Equal(_messageTwo + Environment.NewLine, File.ReadAllText(filePath2)); 550while (!File.Exists(filePath)) 558if (File.ReadAllText(filePath).Length >= length) 581while (File.Exists(filePath))

86var fallbackSrcContent = File.ReadAllText( 129using (var stream = File.OpenRead(cshtmlFile))

142if (File.Exists(testOutputFile)) 150if (!File.Exists(testOutputFile)) 280if (File.Exists(fileName)) 282File.Delete(fileName);

22File.Copy(filePath, uploadPath, overwrite: true);

67while (File.Exists(path))

27if (!File.Exists(procFile)) 32var lines = File.ReadAllLines(procFile);

30RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && File.Exists("/etc/os-release") && 31File.ReadAllLines("/etc/os-release").Any(line =>

67Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist."); 68Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist."); 160Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist"); 161Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist"); 163var globalLogContent = MakeConsistent(File.ReadAllText(globalLogPath)); 164var testLogContent = MakeConsistent(File.ReadAllText(testLog)); 215Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist."); 216Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist."); 221Assert.True(!File.Exists(globalLogPath), $"Expected no global log file {globalLogPath} to exist."); 222Assert.True(!File.Exists(testLog), $"Expected no test log file {testLog} to exist."); 266Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist."); 267Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist."); 343Assert.True(File.Exists(Path.Combine( 353Assert.True(File.Exists(Path.Combine(

44return GetRelatedAssemblies(assembly, throwOnError, File.Exists, new AssemblyLoadContextWrapper(loadContext));

255using (var stream = File.Open(fullPath, FileMode.Create, FileAccess.Write))

75using (var stream = File.OpenRead(path))

361var fromFile = File.Exists("MvcTestingAppManifest.json"); 376var data = JsonSerializer.Deserialize(File.ReadAllBytes(file), CustomJsonSerializerContext.Default.IDictionaryStringString)!; 410if (File.Exists(contentRootMarker))

34using var fileStream = File.Create(ManifestPath);

60File.WriteAllText(classLibProjectPath, classLibProjectContent); 72File.WriteAllText(classLibSourcePath, classLibSourceContent); 80File.Copy(sourceTargetsPath, targetTargetsPath); 98File.WriteAllText(projectPath, projectContent); 111File.WriteAllText(sourcePath, sourceContent);

78if (File.Exists(candidateDotNetExePath))

73Assert.Equal(File.ReadAllBytes(path), memoryStream.ToArray());

26using var file = File.Create(_absoluteFilePath); 37File.Delete(_absoluteFilePath);

309var emptyFile = File.Create(emptyFilePath, 1024); 329File.Delete(emptyFilePath);

110if (File.Exists(stackFrame.File)) 112lines = File.ReadLines(stackFrame.File); 124lines = File.ReadLines(fileInfo.PhysicalPath);

106if (!File.Exists(executableName))

155File.WriteAllText(_configFile, DeploymentParameters.ServerConfigTemplateContent); 180if (!File.Exists(pidFile)) 186var pid = File.ReadAllText(pidFile); 197if (File.Exists(_configFile)) 219File.Delete(_configFile);

186using (var fileStream = File.Open(webConfigFilePath, FileMode.Open)) 325var destinationStream = File.Create(physicalFilePath);

137Logger.LogInformation($"{File.Exists(executableName)}");

25if (!File.Exists(ancmConfigPath))

83DeploymentParameters.ServerConfigTemplateContent = File.ReadAllText("IIS.config"); 186if (File.Exists(file)) 188var lines = File.ReadAllLines(file); 205if (File.Exists(_debugLogFile)) 207File.Delete(_debugLogFile); 311var config = XDocument.Parse(DeploymentParameters.ServerConfigTemplateContent ?? File.ReadAllText("IIS.config")); 515File.WriteAllText(tmpFile, DumpServerManagerConfig());

94var basePath = File.Exists(Path.Combine(AppContext.BaseDirectory, "x64", "aspnetcorev2.dll")) ? "" : @"ANCM\"; 97if (!File.Exists(Environment.ExpandEnvironmentVariables(ancmFile))) 100if (!File.Exists(Environment.ExpandEnvironmentVariables(ancmFile)))

299if (!DeploymentParameters.PublishApplicationBeforeDeployment && !File.Exists(webConfigPath)) 311File.WriteAllText(DeploymentParameters.ServerConfigLocation, serverConfig); 361if (!File.Exists(executableName)) 386if (!File.Exists(iisExpressPath)) 413&& File.Exists(DeploymentParameters.ServerConfigLocation)) 419File.Delete(DeploymentParameters.ServerConfigLocation);

100var keyText = File.ReadAllText(keyPath);

437if (!File.Exists(certificatePath)) 638File.Move(tempFilename, path, overwrite: true); 641File.WriteAllBytes(path, bytes); 666File.Move(tempFilename, keyPath, overwrite: true); 669File.WriteAllBytes(keyPath, pemEnvelope);

120File.Delete(tmpFile); 131return File.Exists(GetCertificateFilePath(candidate)) ? 173File.Delete(tmpFile); 205File.WriteAllBytes(certificatePath, certBytes); 228File.Delete(certificatePath); 323File.WriteAllBytes(GetCertificateFilePath(certificate), certBytes); 343File.WriteAllBytes(certificatePath, certBytes); 464if (File.Exists(certificatePath)) 466File.Delete(certificatePath);

95if (File.Exists(certPath)) 227if (File.Exists(certPath)) 388if (File.Exists(certPath)) 525if (File.Exists(Path.Combine(searchFolder, command))) 677File.Delete(certPath); 912if (!File.Exists(linkPath)) 915File.CreateSymbolicLink(linkPath, cert.Name);

157File.Exists(certificatePath))

38var currentHttpHeadersGenerated = File.ReadAllText(httpHeadersGeneratedPath); 39var currentHttpProtocolGenerated = File.ReadAllText(httpProtocolGeneratedPath); 40var currentHttpUtilitiesGenerated = File.ReadAllText(httpUtilitiesGeneratedPath); 41var currentTransportConnectionBaseGenerated = File.ReadAllText(transportMultiplexedConnectionGeneratedPath); 42var currentTransportConnectionGenerated = File.ReadAllText(transportConnectionGeneratedPath); 50var testHttpHeadersGenerated = File.ReadAllText(testHttpHeadersGeneratedPath); 51var testHttpProtocolGenerated = File.ReadAllText(testHttpProtocolGeneratedPath); 52var testHttpUtilitiesGenerated = File.ReadAllText(testHttpUtilitiesGeneratedPath); 53var testTransportMultiplxedConnectionGenerated = File.ReadAllText(testTransportMultiplexedConnectionGeneratedPath); 54var testTransportConnectionGenerated = File.ReadAllText(testTransportConnectionGeneratedPath); 64File.Delete(testHttpHeadersGeneratedPath); 65File.Delete(testHttpProtocolGeneratedPath); 66File.Delete(testHttpUtilitiesGeneratedPath); 67File.Delete(testTransportMultiplexedConnectionGeneratedPath); 68File.Delete(testTransportConnectionGeneratedPath);

280File.WriteAllBytes(path, bytes); 303if (File.Exists(GetCertificatePath())) 305File.Delete(GetCertificatePath()); 321File.WriteAllBytes(devCertPath, devCertBytes); 385if (File.Exists(GetCertificatePath())) 387File.Delete(GetCertificatePath()); 447File.WriteAllBytes(path, bytes); 477if (File.Exists(GetCertificatePath())) 479File.Delete(GetCertificatePath()); 494File.WriteAllBytes(path, bytes); 526if (File.Exists(GetCertificatePath())) 528File.Delete(GetCertificatePath()); 543File.WriteAllBytes(path, bytes); 579if (File.Exists(GetCertificatePath())) 581File.Delete(GetCertificatePath()); 737File.WriteAllBytes(path, bytes); 752if (File.Exists(GetCertificatePath())) 754File.Delete(GetCertificatePath()); 765if (File.Exists(GetCertificatePath())) 767File.Delete(GetCertificatePath()); 783if (File.Exists(GetCertificatePath())) 785File.Delete(GetCertificatePath()); 893File.WriteAllBytes(certificatePath, oldCertificateBytes); 923File.WriteAllBytes(certificatePath, newCertificateBytes); 947if (File.Exists(certificatePath)) 950File.Delete(certificatePath); 978var fileLink = File.CreateSymbolicLink(Path.Combine(tempDir, "tls.key"), "./link/tls.key"); 987File.WriteAllBytes(oldCertPath, oldCertificateBytes); 992File.WriteAllBytes(newCertPath, newCertificateBytes);

25RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && File.Exists("/etc/os-release") && 26File.ReadAllLines("/etc/os-release").Any(line =>

19Assert.True(File.Exists(muxerPath), "The file did not exist");

78if (File.Exists(candidateDotNetExePath))

65if (File.Exists(candidate))

21if (File.Exists(spaProxyConfigFile))

300File.WriteAllText(scriptPath, stopScript.ReplaceLineEndings());

65if (!File.Exists(manifestPath))

28using var stream = File.OpenRead(manifestPath);

327File.WriteAllText(filePath, "Hello, World!"); 382File.WriteAllText(Path.Combine(webRoot, "sample.txt"), "Hello, World! Modified"); 435File.WriteAllText(Path.Combine(webRoot, "sample.txt"), "Hello, World! Modified"); 459using (var fileStream = File.OpenRead(filePath)) 493File.WriteAllText(filePath, resource.Content); 538using var stream = File.Create(manifestPath); 545using var fileStream = File.Create(filePath); 555using var stream = File.OpenRead(compressedFilePath);

108var last = File.GetLastWriteTimeUtc(Path.Combine(AppContext.BaseDirectory, "TestDocument.txt"));

54Assert.True(File.Exists(badLink), "Should have created a symlink"); 79File.Delete(badLink);

47File.WriteAllText(file, GetJson().ToString(Formatting.Indented));

55if (File.Exists(specFile)) 57File.Delete(specFile); 65using (var reader = new StreamReader(File.OpenRead(outputFile))) 141ServerConfigTemplateContent = (server == ServerType.IISExpress) ? File.ReadAllText(configPath) : null,

25if (File.Exists(candidate))

23return (location == null || !File.Exists(location)) ? null : new Wstest(location);

87return File.Exists(iisExpressExe) && FileVersionInfo.GetVersionInfo(iisExpressExe).FileMajorPart >= 10;

249File.Move(tempTempFileName, _tempFileName);

276File.Move(tempTempFileName, tempFileName);

128Assert.True(File.Exists(tempFileName)); 136Assert.True(File.Exists(tempFileName)); 142Assert.False(File.Exists(tempFileName)); 163Assert.False(File.Exists(stream.TempFileName)); 189Assert.True(File.Exists(tempFileName)); 197Assert.False(File.Exists(tempFileName)); 290Assert.True(File.Exists(tempFileName)); 298Assert.True(File.Exists(tempFileName)); 304Assert.False(File.Exists(tempFileName)); 321Assert.True(File.Exists(tempFileName)); 345Assert.False(File.Exists(tempFileName)); 366Assert.False(File.Exists(stream.TempFileName)); 392Assert.True(File.Exists(tempFileName)); 400Assert.False(File.Exists(tempFileName)); 419Assert.False(File.Exists(stream.TempFileName), "tempFile should not be created as yet"); 422Assert.True(File.Exists(stream.TempFileName), "tempFile should be created"); 429Assert.False(File.Exists(tempFileName)); 448Assert.False(File.Exists(stream.TempFileName), "tempFile should not be created as yet"); 451Assert.True(File.Exists(stream.TempFileName), "tempFile should be created"); 458Assert.False(File.Exists(tempFileName)); 623Assert.True(File.Exists(tempFileName)); 624Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(tempFileName)); 627Assert.False(File.Exists(tempFileName));

383Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(bufferingStream.FileStream.SafeFileHandle));

2056File.WriteAllText(logPath, graph.ToDot(targetList)); 3277if (inputCacheFiles.Any(f => !File.Exists(f))) 3279LogErrorAndShutdown(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("InputCacheFilesDoNotExist", string.Join(";", inputCacheFiles.Where(f => !File.Exists(f)))));

122using (var fileStream = File.OpenRead(inputCacheFile))

147_ = File.Exists(filePath);

107using (StreamWriter file = new StreamWriter(File.Open(planName, FileMode.Create))) 161using (StreamReader file = new StreamReader(File.Open(planName, FileMode.Open)))

716using Stream stream = File.Create(cacheFile); 755using Stream stream = File.OpenRead(cacheFile);

108using Stream stream = File.OpenRead(cacheFile); 224using Stream stream = File.OpenRead(cacheFile); 294using Stream stream = File.Create(cacheFile);

54return EditorConfigFile.Parse(File.ReadAllText(editorConfigFilePath));

609var existsCheck = mode == BuildEnvironmentMode.VisualStudio ? new Func<string, bool>(_ => true) : File.Exists;

1997string contents = File.ReadAllText(path);

315FileStream fs = File.OpenRead(AbsolutePath);

554fileStream = File.OpenRead(solutionFile); 672JsonDocument text = JsonDocument.Parse(File.ReadAllText(solutionFilterFile), options); 745fileStream = File.OpenRead(_solutionFile); 1173FileStream fs = File.OpenRead(fullPathToEtpProj);

115while (File.Exists(fullPath))

1899if (File.Exists(dotnetExe))

44File.AppendAllText(logFile, $"ReceiverType={receiverType?.FullName}; ObjectInstanceType={objectInstance?.GetType().FullName}; MethodName={methodName}({argSignature})\n");

742if (File.Exists(pathToAssembly))

394if (File.GetLastWriteTimeUtc(file) >= fromTimeUtc) 400builder.Append(File.ReadAllText(file));

81return !File.Exists(lowerCased); 198File.WriteAllText(testFilePath, $"MSBuild process {EnvironmentUtilities.CurrentProcessId} successfully wrote to file."); 199File.Delete(testFilePath); 894File.Delete(FixFilePath(path));

1435(!File.Exists(Path.Combine(generatedPathToDotNetFramework, NativeMethodsShared.IsWindows ? "MSBuild.exe" : "mcs.exe")) && 1436!File.Exists(Path.Combine(generatedPathToDotNetFramework, "Microsoft.Build.dll"))))

225if (checkFileExistence && !File.Exists(filePath)) 273using FileStream fileStream = File.OpenRead(_archiveFilePath); 307File.Delete(_archiveFilePath);

296File.WriteAllText(FileToLog, content);

51return File.ReadAllText(path); 56return File.ReadAllBytes(path); 131return File.GetAttributes(path); 136return File.GetLastWriteTimeUtc(path); 146return File.Exists(path);

331modifiedItemSpec = File.GetCreationTime(unescapedItemSpec).ToString(FileTimeFormat, null); 347modifiedItemSpec = File.GetLastAccessTime(unescapedItemSpec).ToString(FileTimeFormat, null);

28File.AppendAllText(file, CsvFormat(string.Empty, callsite, args)); 33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

308var fileType = new Tuple<string, Type>(null, typeof(File));

192File.WriteAllText(file, string.Empty);

98File.Delete(tempFileName + ".config"); 99File.Delete(tempFileName);

165File.Copy( 179JsonNode? depsJson = JsonObject.Parse(File.ReadAllText(depsFiles[0])); 191File.Exists(filePath).ShouldBeTrue($"File {filePath} expected to exist."); 192string text = File.ReadAllText(filePath); 194File.WriteAllText(filePath, text); 209File.Copy(newPath, newPath.Replace(sourcePath, targetPath), true); 257File.GetLastWriteTimeUtc(outFile1[0]), 258File.GetLastWriteTimeUtc(outFile2[0]), 259File.GetLastAccessTimeUtc(outFile1[0]), 260File.GetLastAccessTimeUtc(outFile2[0])); 299File.WriteAllLines(output2.File1Path, ["foo"]); 300File.WriteAllLines(output2.File2Path, ["foo"]); 302DateTime file1WriteUtc = File.GetLastWriteTimeUtc(output2.File1Path); 303DateTime file2WriteUtc = File.GetLastWriteTimeUtc(output2.File2Path); 400File.Exists(filePath).ShouldBeTrue($"File {filePath} expected to exist."); 401string text = File.ReadAllText(filePath); 403File.WriteAllText(filePath, text); 513File.AppendAllText(editorconfigFile.Path, editorConfigChange); 666File.WriteAllText(editorConfigName, ReadEditorConfig( 682File.Delete(editorConfigName); 877File.WriteAllText(editorConfigName, ReadEditorConfig( 888File.Delete(editorConfigName); 906File.WriteAllText(editorConfigName, ReadEditorConfig( 920File.Delete(editorConfigName); 948File.Copy(nugetTemplatePath, Path.Combine(workFolder.Path, nugetTemplateName)); 975doc.LoadXml(File.ReadAllText(nugetTemplatePath)); 1073File.ReadAllText(Path.Combine(TestAssetsRootPath, testAssetsFolderName, fileName)) 1097string configContent = File.ReadAllText(Path.Combine(TestAssetsRootPath, testAssetsFolderName, $"{EditorConfigFileName}test"));

115using (XmlReader xr = XmlReader.Create(File.OpenRead(potentialVersionsPropsPath), xrs))

1198if (File.Exists(filename)) 1200File.Delete(filename);

115using (XmlReader xr = XmlReader.Create(File.OpenRead(potentialVersionsPropsPath), xrs))

841File.Exists(resultFile).ShouldBeTrue(); 842File.ReadAllText(resultFile).ShouldContain(result); 1076else if (File.Exists(path)) 1078File.SetAttributes(path, File.GetAttributes(path) & ~FileAttributes.ReadOnly); // make writable 1079File.Delete(path); 1123File.Delete(projectFileName); 1166File.Exists(logFile).ShouldBeTrue(); 1168var logFileContents = File.ReadAllText(logFile); 1181File.Delete(projectFileName); 1182File.Delete(logFile); 1198File.Exists(_pathToArbitraryBogusFile).ShouldBeTrue(); 1213File.Exists(_pathToArbitraryBogusFile).ShouldBeTrue(); 1267File.WriteAllText(projectPath, content); 1270File.WriteAllText(rspPath, rspContent); 1381File.WriteAllText(mainRspPath, "/p:A=0"); 1384File.WriteAllText(projectPath, content); 1386File.WriteAllText(rspPath, "/p:A=1"); 1419File.WriteAllText(projectPath, content); 1421File.WriteAllText(rspPath, "/p:A=1"); 2523File.WriteAllText(dllFilePath, "Invalid content, not a valid .NET assembly."); 2886File.Copy(file, Path.Combine(dest, Path.GetFileName(file))); 2931File.WriteAllText(Path.Combine(testProject.TestRoot, item.Key), item.Value); 2963File.Copy(file, destPath, true);

609var existsCheck = mode == BuildEnvironmentMode.VisualStudio ? new Func<string, bool>(_ => true) : File.Exists;

3217File.WriteAllText(sdkPropsPath, "<Project />"); 3218File.WriteAllText(sdkTargetsPath, "<Project />"); 3229File.WriteAllText(testProject.ProjectFile, content); 3239var updatedContents = File.ReadAllText(updated);

413File.WriteAllText(file, projectContents); 468File.WriteAllText(file, originalContents); 689File.WriteAllText(file, content, new UTF8Encoding(encoderShouldEmitUTF8Identifier: byteOrderMark)); 698string actualContents = File.ReadAllText(file);

191File.Delete(file1); 192File.Delete(file2); 230File.Delete(file); 273if (File.Exists(targetsFile)) 275File.Delete(targetsFile);

429File.WriteAllText(path, content); 442File.Delete(path); 461File.WriteAllText(path, content); 479File.Delete(path); 498File.WriteAllText(path, content); 502File.WriteAllText(path, content2); 513File.Delete(path); 614string actual = File.ReadAllText(file); 619File.Delete(file); 640Assert.True(File.Exists(path)); 672Assert.True(File.Exists(file)); 743File.Delete(projectFullPath); 773File.Delete(projectFullPath); 1000File.WriteAllText(solutionFile, content); 1006File.Delete(solutionFile); 1081File.Delete(paths[i]); 1147File.Delete(paths[i]); 1741File.WriteAllText(initialLocation, ObjectModelHelpers.CleanupFileContents(SimpleProject)); 1757File.WriteAllText(reloadLocation, ObjectModelHelpers.CleanupFileContents(ComplexProject));

471File.WriteAllText(file, ObjectModelHelpers.CleanupFileContents(projectContents));

115while (File.Exists(fullPath))

1708File.WriteAllText(projectFile, p);

187File.WriteAllText(file, content); 195File.Delete(file); 227File.WriteAllText(file, ObjectModelHelpers.CleanupFileContents(@"<Project xmlns='msbuildnamespace'/>")); 233File.Delete(file); 419File.Delete(file); 454File.Delete(file); 455File.Delete(file2); 490File.Delete(file); 491File.Delete(file2); 533File.Delete(file); 534File.Delete(file2); 535File.Delete(file3); 658File.Delete(file); 726File.Delete(file); 762File.Delete(file); 801File.Delete(file); 1376File.Delete(path); 1418File.Delete(path); 1737File.WriteAllText(filePath, string.Empty); 1777File.Delete(filePathToRemove); 2093File.WriteAllText(importFileName, importProjectContent); 2198File.Delete(file); 3978File.WriteAllText(importFile.Path, contents); 4025File.WriteAllText(importFile.Path, contents); 4292File.Delete(file);

79File.Delete(path); 108File.Delete(path); 137File.Delete(path); 176File.Delete(path); 207File.Delete(path); 238File.Delete(path); 312File.Delete(path); 361File.Delete(path); 849File.Delete(file1); 854File.Delete(file2); 892File.Delete(file1); 897File.Delete(file2); 935File.Delete(file1); 940File.Delete(file2);

323File.WriteAllText(path, String.Empty); 334File.Delete(path); 351if (File.Exists(directory)) 353File.Delete(directory); 357if (File.Exists(subdirectory)) 359File.Delete(subdirectory); 365File.WriteAllText(file, String.Empty); 376File.Delete(file); 398if (File.Exists(directory)) 400File.Delete(directory); 404if (File.Exists(subdirectory)) 406File.Delete(subdirectory); 412File.WriteAllText(file, String.Empty); 423File.Delete(file); 1109File.WriteAllText(projectFile, formattedProject); 1991File.Create(sourceFile).Dispose(); 2001File.Move(sourceFile, renamedSourceFile); // repro w/ or w/o this 2071File.Delete(file); 2102File.Delete(file); 2134File.Delete(file);

139File.Delete(file); 183File.Delete(file);

277File.Delete(file);

107File.WriteAllText(_importFilename, importContents); 115if (File.Exists(_importFilename)) 117File.Delete(_importFilename);

394if (File.GetLastWriteTimeUtc(file) >= fromTimeUtc) 400builder.Append(File.ReadAllText(file));

81return !File.Exists(lowerCased); 198File.WriteAllText(testFilePath, $"MSBuild process {EnvironmentUtilities.CurrentProcessId} successfully wrote to file."); 199File.Delete(testFilePath); 894File.Delete(FixFilePath(path));

290File.WriteAllText(file1, String.Empty); 291File.WriteAllText(file2, String.Empty); 292File.WriteAllText(file3, String.Empty); 314File.Delete(file1); 315File.Delete(file2); 316File.Delete(file3); 500File.Delete(tempDir); 502File.Create(Path.Combine(tempDir, "aItem.cs")).Dispose(); 628File.WriteAllText(projectA, ObjectModelHelpers.CleanupFileContents(contentsA)); 629File.WriteAllText(projectB, ObjectModelHelpers.CleanupFileContents(contentsB)); 631File.WriteAllText(includeFileA, "aaaaaaa"); 632File.WriteAllText(includeFileB, "bbbbbbb"); 640if (File.Exists(projectA)) 642File.Delete(projectA); 645if (File.Exists(projectB)) 647File.Delete(projectB); 650if (File.Exists(includeFileA)) 652File.Delete(includeFileA); 655if (File.Exists(includeFileB)) 657File.Delete(includeFileB);

127File.Delete(path);

51return File.ReadAllText(path); 56return File.ReadAllBytes(path); 131return File.GetAttributes(path); 136return File.GetLastWriteTimeUtc(path); 146return File.Exists(path);

48Assert.True(File.Exists(proj1Path)); 49Assert.False(File.Exists(savedPath)); 68Assert.True(File.Exists(savedPath));

28File.AppendAllText(file, CsvFormat(string.Empty, callsite, args)); 33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

192File.WriteAllText(file, string.Empty);

115using (XmlReader xr = XmlReader.Create(File.OpenRead(potentialVersionsPropsPath), xrs))

108File.WriteAllText(absolute, content);

72return File.Exists(path);

99File.WriteAllText(child1ProjectPath, cleanedUpChildContents); 103File.WriteAllText(mainProjectPath, cleanedUpMainContents);

765File.WriteAllText(tempProject, projectContents); 1878File.WriteAllText(projectFile, contents); 2041File.WriteAllText(p2pProject, contents2); 2096File.WriteAllText(importedProjectPath, contents2); 2097File.WriteAllText(rootProjectPath, String.Format(CultureInfo.InvariantCulture, contents1, importedProjectPath)); 2195File.WriteAllText(fileName, contents); 2263File.WriteAllText(fileName, contents); 2314File.WriteAllText(fileName, contents); 2406File.WriteAllText(projA, CleanupFileContents(contentsA)); 2407File.WriteAllText(projB, CleanupFileContents(contentsB)); 2467File.WriteAllText(projA, CleanupFileContents(contentsA)); 2468File.WriteAllText(projB, CleanupFileContents(contentsB)); 2525File.WriteAllText(projA, CleanupFileContents(contentsA)); 2526File.WriteAllText(projB, CleanupFileContents(contentsB)); 2574File.WriteAllText(projA, CleanupFileContents(contentsA)); 2575File.WriteAllText(projB, CleanupFileContents(contentsB)); 2659File.WriteAllText(projA, contentsA); 2660File.WriteAllText(projB, contentsB); 2661File.WriteAllText(projC, contentsC); 2662File.WriteAllText(projD, contentsD); 2730File.WriteAllText(projA, CleanupFileContents(contentsA)); 2731File.WriteAllText(projB, CleanupFileContents(contentsB)); 2732File.WriteAllText(projC, CleanupFileContents(contentsC)); 2827File.WriteAllText(projA, CleanupFileContents(contentsA)); 2828File.WriteAllText(projB, CleanupFileContents(contentsB)); 2829File.WriteAllText(projC, CleanupFileContents(contentsC)); 2927File.WriteAllText(projA, CleanupFileContents(contentsA)); 2928File.WriteAllText(projB, CleanupFileContents(contentsB)); 2929File.WriteAllText(projC, CleanupFileContents(contentsC)); 3013File.WriteAllText(projA, CleanupFileContents(contentsA)); 3014File.WriteAllText(projB, CleanupFileContents(contentsB)); 3015File.WriteAllText(projC, CleanupFileContents(contentsC)); 3085File.WriteAllText(projA, CleanupFileContents(contentsA)); 3086File.WriteAllText(projB, CleanupFileContents(contentsB)); 3118File.WriteAllText(projectPath1, CleanupFileContents(projectContent)); 3123File.WriteAllText(projectPath2, CleanupFileContents(projectContent)); 3186File.WriteAllText(projectPath1, CleanupFileContents(projectContent1)); 3201File.WriteAllText(projectPath2, CleanupFileContents(projectContent2)); 3271File.WriteAllText(projectPath1, CleanupFileContents(projectContent1)); 3286File.WriteAllText(projectPath2, CleanupFileContents(projectContent2)); 3369File.WriteAllText(fileName, contents); 3504File.WriteAllText(fileName, contents); 3587File.WriteAllText(projectFilePath, contents); 3608File.Delete(project.FullPath); 3695File.WriteAllText(p2pProjectPath, p2pProjectContents); 3791File.WriteAllText(p2pProjectPath, cleanedUpP2pContents); 3795File.WriteAllText(mainProjectPath, cleanedUpMainContents); 3847File.WriteAllText(importPath, CleanupFileContents(importProject)); 3947File.WriteAllText(child1ProjectPath, cleanedUpChildContents); 3948File.WriteAllText(child2ProjectPath, cleanedUpChildContents); 3952File.WriteAllText(mainProjectPath, cleanedUpMainContents); 4185File.WriteAllText(project1, CleanupFileContents($@" 4196File.WriteAllText(project2, CleanupFileContents(@" 4227File.WriteAllText(project1, CleanupFileContents($@" 4239File.WriteAllText(project2, CleanupFileContents(@" 4244File.WriteAllText(project3, CleanupFileContents(@" 4268File.WriteAllText(project1, CleanupFileContents($@" 4279File.WriteAllText(project2, CleanupFileContents(@" 4311File.WriteAllText(project1, CleanupFileContents($@" 4322File.WriteAllText(project2, CleanupFileContents($@"

112File.Delete(cacheFile); 146File.Delete(cacheFile);

36File.ReadAllText(exceptionFile).ShouldContain("hello world"); 37File.Delete(exceptionFile);

3347File.WriteAllText(fileForTest, fileForTest); 3385File.WriteAllText(importedFile, ObjectModelHelpers.CleanupFileContents(@" 3424File.WriteAllText(importedFile, ObjectModelHelpers.CleanupFileContents(@"

486if (File.Exists(targetsFile)) 488File.Delete(targetsFile); 491if (File.Exists(projectFile)) 493File.Delete(projectFile);

89File.Delete(tempProject); 165File.Delete(projectFile1); 166File.Delete(projectFile2); 574File.Delete(projectFile1); 575File.Delete(projectFile2); 641File.Delete(projectFile1); 642File.Delete(projectFile2); 695File.Delete(projectFile); 767File.Delete(projectFile); 947File.Delete(projectFile1); 948File.Delete(projectFile2); 1003File.Delete(projectFile1); 1004File.Delete(projectFile2); 1069File.Delete(projectFile1); 1070File.Delete(projectFile2); 1138File.Delete(projectFile1); 1139File.Delete(projectFile2); 1204File.Delete(projectFile1); 1205File.Delete(projectFile2); 1260File.Delete(projectFile1); 1261File.Delete(projectFile2); 1390File.Delete(project1); 1391File.Delete(project2); 1587File.Delete(project1); 1588File.Delete(project2); 1742File.Delete(project1); 1818File.Delete(projectFile1); 1819File.Delete(projectFile2); 1858File.Delete(projectFile1); 1859File.Delete(projectFile2); 1894File.Delete(projectFile1); 1895File.Delete(projectFile2);

259File.WriteAllText(projectFile, projectFileContents.Replace('`', '"')); 280if (File.Exists(fileName)) 282File.Delete(fileName);

72File.WriteAllText(f1, string.Empty); 73File.WriteAllText(f2, string.Empty); 74File.WriteAllText(f3, string.Empty); 75File.WriteAllText(f4, string.Empty); 101File.WriteAllText(wrongResolverDll, string.Empty); 102File.WriteAllText(assemblyToLoad, string.Empty); 104File.WriteAllText(resolverManifest, $@" 227File.WriteAllText(resolverManifest, $@" 252File.WriteAllText(resolverManifest, $@" 279File.WriteAllText(resolverManifest, $@" 320File.WriteAllText(resolverManifest, $@" 373File.WriteAllText(Path.Combine(testRoot, resolver1, $"{resolver1}.dll"), string.Empty); 375File.WriteAllText(resolver1Path, string.Empty); 379File.WriteAllText(resolver2Path, string.Empty); 383File.WriteAllText(resolver3Path, string.Empty);

108File.WriteAllText(projectPath, CleanupFileContents(contents)); 143File.WriteAllText(entryProjectPath, CleanupFileContents(entryProjectContents)); 153File.WriteAllText(projectWithSdkImportPath, CleanupFileContents(projectWithSdkImportContents)); 233File.WriteAllText(Path.Combine(projectFolder, "Sdk1", "Sdk.props"), CleanupFileContents(sdk1propsContents)); 234File.WriteAllText(Path.Combine(projectFolder, "Sdk2", "Sdk.props"), CleanupFileContents(sdk2propsContents));

78File.Delete("testProject.proj"); 333File.Delete(path); 1664File.Create("testProject.proj").Dispose();

69File.Delete("testProject.proj"); 865File.Delete(project.FullPath); 1178FileStream stream = File.Create("testProject.proj");

420File.WriteAllText("foo1.txt", ""); 421File.WriteAllText("foo.txt", ""); 423File.WriteAllText("1111", ""); 424File.WriteAllText("a", ""); 449File.Delete("foo1.txt"); 450File.Delete("foo.txt"); 451File.Delete("a"); 452File.Delete("1111"); 581File.SetCreationTime(path, filesToAnalyze[i].LastWriteTime); 582File.SetLastWriteTime(path, filesToAnalyze[i].LastWriteTime); 600File.WriteAllText(projectFile, formattedProjectXml); 622if (File.Exists(path)) 624File.Delete(path); 885File.WriteAllText(input1, String.Empty); 886File.SetLastWriteTime(input1, (DateTime)input1Time); 892File.WriteAllText(input2, String.Empty); 893File.SetLastWriteTime(input2, (DateTime)input2Time); 899File.WriteAllText(output1, String.Empty); 900File.SetLastWriteTime(output1, (DateTime)output1Time); 906File.WriteAllText(output2, String.Empty); 907File.SetLastWriteTime(output2, (DateTime)output2Time); 935if (File.Exists(input1)) 937File.Delete(input1); 940if (File.Exists(input2)) 942File.Delete(input2); 945if (File.Exists(output1)) 947File.Delete(output1); 950if (File.Exists(output2)) 952File.Delete(output2); 1030File.SetLastWriteTime(inputTarget, targetWriteTime); 1066File.SetLastWriteTime(outputTarget, outputWriteTime); 1078if (File.Exists(inputTarget)) 1080File.Delete(inputTarget); 1083if (File.Exists(inputSymlink)) 1085File.Delete(inputSymlink); 1088if (File.Exists(outputTarget)) 1090File.Delete(outputTarget);

994File.WriteAllText(projectAPath, ObjectModelHelpers.CleanupFileContents(projectAContents)); 995File.WriteAllText(projectBPath, ObjectModelHelpers.CleanupFileContents(projectBContents)); 1003if (File.Exists(projectAPath)) 1005File.Delete(projectAPath); 1008if (File.Exists(projectBPath)) 1010File.Delete(projectBPath);

1089File.Exists(ExceptionHandling.DumpFilePath).ShouldBe(isCritical,

221File.WriteAllText(project.FullPath, projectText); 223File.Delete(project.FullPath); 361string text = File.ReadAllText(Path.Combine(logFolder.Path, "logFile.log")); 420string text = File.ReadAllText(Path.Combine(logFolder.Path, "logFile.log")); 424string text2 = File.ReadAllText(Path.Combine(logFolder.Path, "logFile2.log")); 429text = File.ReadAllText(Path.Combine(logFolder.Path, "logFile3.log")); 433text2 = File.ReadAllText(Path.Combine(logFolder.Path, "logFile4.log")); 668File.Exists(binaryLogger.FilePath).ShouldBeTrue(); 672File.Create(_logFile).Dispose(); 689File.Exists(binaryLogger.FilePath).ShouldBeTrue(); 693File.Create(_logFile).Dispose();

478File.WriteAllText(Path.Combine(BuildDirectory, file), string.Empty); 484File.WriteAllText(Path.Combine(BuildDirectory64, file), string.Empty); 488File.WriteAllText(DevEnvPath, string.Empty); 523File.WriteAllText(MSBuildExePath, string.Empty); 524File.WriteAllText($"{MSBuildExePath}.config", string.Empty); 529File.WriteAllText(Path.Combine(BuildDirectory, "amd64", msBuildExeName), string.Empty); 530File.WriteAllText(Path.Combine(BuildDirectory, "amd64", $"{MSBuildExePath}.config"), string.Empty);

386File.WriteAllText(tempProjectPath, s_dummyProjectContents);

107File.WriteAllText(file, ObjectModelHelpers.CleanupFileContents("<Project xmlns='msbuildnamespace' ToolsVersion='msbuilddefaulttoolsversion'>\r\n<ItemGroup>") + new string(' ', 70000) + @"<x/></ItemGroup></Project>"); 118File.Delete(file); 142File.WriteAllText(file, ObjectModelHelpers.CleanupFileContents("<Project xmlns='msbuildnamespace' ToolsVersion='msbuilddefaulttoolsversion'>\r\n<ItemGroup>") + longstring + @" <x/></ItemGroup></Project>"); 153File.Delete(file); 423File.WriteAllText(file, content); 450File.Delete(file);

191File.WriteAllText(proj1Path, etpProjContent); 209File.Delete(proj1Path); 258File.WriteAllText(proj1Path, etpProjContent); 259File.WriteAllText(proj2Path, genericProj); 284File.Delete(proj1Path); 285File.Delete(proj2Path); 312File.WriteAllText(rptprojPath, rptprojProjContent); 314File.WriteAllText(dqprojPath, dwprojProjContent); 363File.WriteAllText(proj1Path, etpProjContent); 380File.WriteAllText(proj2Path, etpProjContent); 400File.Delete(proj1Path); 401File.Delete(proj2Path); 559File.WriteAllText(proj1Path, etpProjContent); 576File.WriteAllText(proj2Path, etpProjContent); 595File.WriteAllText(proj3Path, etpProjContent); 618File.Delete(proj1Path); 619File.Delete(proj2Path); 620File.Delete(proj3Path); 655File.WriteAllText(proj1Path, etpProjContent); 678File.Delete(proj1Path); 699File.Delete(proj1Path);

210Assert.False(File.Exists("C:\\notAPath2\\MSBuild.Dev.sln"));

2041Assert.True(File.Exists(solution.FullPath + ".metaproj")); // "Solution parser should have written in-memory project to disk" 2042File.Delete(solution.FullPath + ".metaproj"); 2133File.Delete(projectFilePath); 2193File.WriteAllText(projectFilePath, solutionFileContents.Replace('\'', '"')); 2213File.Delete(projectFilePath); 2281File.WriteAllText(projectFilePath, solutionFileContents.Replace('\'', '"')); 2301File.Delete(projectFilePath); 2399File.Delete(projectFilePath);

1217File.WriteAllText(importedFile, @" 1798File.Delete(otherProject); 1850File.Delete(otherProject);

378File.WriteAllText(Path.Combine(projectDirectory, $"{evaluationCount}.cs"), ""); 388File.WriteAllText(Path.Combine(projectDirectory, $"{evaluationCount}.cs"), ""); 438File.WriteAllText(Path.Combine(projectDirectory1, $"1.{evaluationCount}.cs"), ""); 439File.WriteAllText(Path.Combine(projectDirectory2, $"2.{evaluationCount}.cs"), ""); 472File.WriteAllText(Path.Combine(projectDirectory1, $"1.{evaluationCount}.cs"), ""); 473File.WriteAllText(Path.Combine(projectDirectory2, $"2.{evaluationCount}.cs"), ""); 493File.WriteAllText(Path.Combine(project1GlobDirectory, $"1.{evaluationCount}.cs"), ""); 494File.WriteAllText(Path.Combine(project2GlobDirectory, $"2.{evaluationCount}.cs"), ""); 529File.WriteAllText(Path.Combine(project1GlobDirectory, $"1.{evaluationCount}.cs"), ""); 530File.WriteAllText(Path.Combine(project2GlobDirectory, $"2.{evaluationCount}.cs"), ""); 555File.WriteAllText(Path.Combine(project1GlobDirectory, $"{evaluationCount}.cs"), ""); 600File.WriteAllText(Path.Combine(project1GlobDirectory, $"{evaluationCount}.cs"), ""); 622File.WriteAllText(Path.Combine(globDirectory.Path, $"{evaluationCount}.cs"), ""); 660File.WriteAllText(Path.Combine(globDirectory.Path, $"{evaluationCount}.cs"), ""); 726File.WriteAllText(Path.Combine(globDirectory.Path, $"{evaluationCount}.cs"), ""); 736File.WriteAllText(Path.Combine(globDirectory.Path, $"{evaluationCount}.cs"), ""); 763File.WriteAllText(Path.Combine(projectDirectory, $"{evaluationCount}.props"), $"<Project><ItemGroup><i Include=`{evaluationCount}.cs`/></ItemGroup></Project>".Cleanup()); 773File.WriteAllText(Path.Combine(projectDirectory, $"{evaluationCount}.props"), $"<Project><ItemGroup><i Include=`{evaluationCount}.cs`/></ItemGroup></Project>".Cleanup()); 805File.WriteAllText(theFile, ""); 816if (File.Exists(theFile)) 818File.Delete(theFile); 993File.WriteAllText(projectFilePath, projectContents.Cleanup());

36if (File.Exists(configFilePath)) 38File.Delete(configFilePath); 41File.WriteAllText(configFilePath, content);

567File.Delete(inputFile); 572File.Delete(outputFile); 658if (File.Exists(projectAbsolutePath)) 660File.Delete(projectAbsolutePath); 1805File.WriteAllText(Path.Combine(ObjectModelHelpers.TempProjectDir, "a.weirdo"), String.Empty); 1806File.WriteAllText(Path.Combine(ObjectModelHelpers.TempProjectDir, "b.weirdo"), String.Empty); 1807File.WriteAllText(Path.Combine(ObjectModelHelpers.TempProjectDir, "c.weirdo"), String.Empty);

78File.WriteAllText(importFile, projectImportContents); 83File.WriteAllText(projectFile, projectContents);

347File.WriteAllText(testTargetPath, ObjectModelHelpers.CleanupFileContents(testtargets)); 348File.WriteAllText(subdirProjPath, ObjectModelHelpers.CleanupFileContents(subdirTestProj)); 349File.WriteAllText(textTextPath, testTxt); 350File.WriteAllText(targetDirectoryTargetsPath, ObjectModelHelpers.CleanupFileContents(targetDirTargets)); 351File.WriteAllText(targetDirectoryTargetsPath2, ObjectModelHelpers.CleanupFileContents(targetDirTargets2)); 352File.WriteAllText(projectDirectoryTargetsPath, ObjectModelHelpers.CleanupFileContents(projDirTargets)); 353File.WriteAllText(projectDirectoryTargetsPath2, ObjectModelHelpers.CleanupFileContents(projDirTargets2)); 476File.WriteAllText(testTargetPath, ObjectModelHelpers.CleanupFileContents(testtargets)); 477File.WriteAllText(subdirProjPath, ObjectModelHelpers.CleanupFileContents(subdirTestProj)); 478File.WriteAllText(textTextPath, testTxt); 479File.WriteAllText(targetDirectoryTargetsPath, ObjectModelHelpers.CleanupFileContents(targetDirTargets)); 480File.WriteAllText(targetDirectoryTargetsPath2, ObjectModelHelpers.CleanupFileContents(targetDirTargets2)); 481File.WriteAllText(projectDirectoryTargetsPath, ObjectModelHelpers.CleanupFileContents(projDirTargets)); 482File.WriteAllText(projectDirectoryTargetsPath2, ObjectModelHelpers.CleanupFileContents(projDirTargets2)); 544File.WriteAllText(targetAPath, targetA); 545File.WriteAllText(targetBPath, targetB); 546File.WriteAllText(projectPath, projectContents); 589File.WriteAllText(testTargetPath, testtargets); 634File.WriteAllText(testTargetPath, testtargets); 677File.WriteAllText(testTargetPath, testtargets); 723File.WriteAllText(testTargetPath, testtargets); 767File.WriteAllText(testTargetPath, testtargets); 813File.WriteAllText(testTargetPath, testtargets); 855File.WriteAllText(importPath, import); 891File.Delete(importPath); 929File.WriteAllText(importPath, import2); 930File.WriteAllText(importPath2, import2); 931File.WriteAllText(importPath3, import); 968File.Delete(importPath); 969File.Delete(importPath2); 970File.Delete(importPath3); 1030File.WriteAllText(importPath1, import1); 1031File.WriteAllText(importPath2, import2); 1054File.Delete(importPath1); 1055File.Delete(importPath2); 1092File.WriteAllText(importPath1, import1); 1093File.WriteAllText(importPath2, import2); 1110File.Delete(importPath1); 1111File.Delete(importPath2); 1182File.WriteAllText(importPath1, import1); 1183File.WriteAllText(importPath2, import2); 1200File.Delete(importPath1); 1201File.Delete(importPath2); 1202File.Delete(projectPath); 1890File.Delete(file); 2082File.Delete(file); 2157File.Delete(file); 3436File.WriteAllText(primaryProject, projectContents); 3437File.WriteAllText(import, importContents); 3497File.WriteAllText(primaryProject, projectContents); 3498File.WriteAllText(import, importContents); 3557File.WriteAllText(primaryProject, projectContents); 3558File.WriteAllText(import, importContents); 3629File.WriteAllText(primaryProject, projectContents); 3630File.WriteAllText(import, importContents); 3702File.WriteAllText(primaryProject, projectContents); 3703File.WriteAllText(import, importContents); 3767File.WriteAllText(primaryProject, projectContents); 3768File.WriteAllText(project2, project2Contents); 3829File.WriteAllText(primaryProject, projectContents); 3830File.WriteAllText(project2, project2Contents); 4413File.WriteAllText(projectFilename, projectContents); 4567File.WriteAllText(primaryProject, projectContents); 4568File.WriteAllText(import, importContents); 4669File.SetLastWriteTime(project1.ProjectFile, DateTime.Now.AddHours(-1)); 4670File.SetLastWriteTime(project2.ProjectFile, DateTime.Now); 4671File.SetLastWriteTime(primaryProject.ProjectFile, DateTime.Now.AddHours(-1)); 4698File.SetLastWriteTime(project1.ProjectFile, DateTime.Now.AddHours(-1)); 4699File.SetLastWriteTime(project2.ProjectFile, DateTime.Now.AddHours(-1)); 4700File.SetLastWriteTime(primaryProject.ProjectFile, DateTime.Now); 5228if (File.Exists(directory)) 5269File.Delete(file1); 5270File.Delete(file2); 5271File.Delete(file3); 5272File.Delete(file4);

3407File.Delete(tempFile); 3708File.SetAttributes(tempFile, FileAttributes.ReadOnly | FileAttributes.Archive); 3716File.SetAttributes(tempFile, FileAttributes.Normal); 3717File.Delete(tempFile); 5173File.Exists(reflectionInfoPath).ShouldBeFalse();

1001File.WriteAllText(Path.Combine(extnDir, relativeFilePath), fileContents);

131File.WriteAllText(testFilePath, "Test content");

592File.WriteAllText(projectFiles.CreatedFiles[0], import);

779File.Delete(xml1.FullPath); 780File.Delete(xml2.FullPath); 781File.Delete(xml3.FullPath); 861File.WriteAllText(sdkPropsPath, @"<Project> 866File.WriteAllText(sdkTargetsPath, @"<Project> 975File.WriteAllText(importedPropsPath, @"<Project> 982File.WriteAllText(projectPath, content); 1068File.WriteAllText(sdkPropsPath1, @"<Project> 1073File.WriteAllText(sdkTargetsPath1, @"<Project> 1082File.WriteAllText(sdkPropsPath2, @"<Project> 1087File.WriteAllText(sdkTargetsPath2, @"<Project>

124File.SetLastWriteTime(path, DateTime.Now + new TimeSpan(1, 0, 0)); 131File.Delete(path); 158File.SetLastWriteTime(path, DateTime.Now + new TimeSpan(1, 0, 0)); 165File.Delete(path);

104File.WriteAllText(_sdkPropsPath, _sdkPropsContent); 105File.WriteAllText(_sdkTargetsPath, _sdkTargetsContent); 128File.WriteAllText(_sdkPropsPath, _sdkPropsContent); 129File.WriteAllText(_sdkTargetsPath, _sdkTargetsContent); 194File.WriteAllText(Path.Combine(testSdkDirectory, "Sdk.props"), $"<Project><PropertyGroup><InitialImportProperty>{sdkName}</InitialImportProperty></PropertyGroup></Project>"); 195File.WriteAllText(Path.Combine(testSdkDirectory, "Sdk.targets"), $"<Project><PropertyGroup><FinalImportProperty>{sdkName}</FinalImportProperty></PropertyGroup></Project>"); 237File.WriteAllText(_sdkPropsPath, "<Project />"); 238File.WriteAllText(_sdkTargetsPath, "<Project />"); 271File.WriteAllText(_sdkPropsPath, " <Project />"); 272File.WriteAllText(_sdkTargetsPath, "<Project />"); 346File.WriteAllText(_sdkPropsPath, _sdkPropsContent); 347File.WriteAllText(_sdkTargetsPath, _sdkTargetsContent); 362File.WriteAllText(p1Path, p1); 363File.WriteAllText(p2Path, p2); 438File.WriteAllText(_sdkPropsPath, _sdkPropsContent); 439File.WriteAllText(_sdkTargetsPath, _sdkTargetsContent); 515File.WriteAllText(_sdkPropsPath, _sdkPropsContent); 516File.WriteAllText(_sdkTargetsPath, _sdkTargetsContent); 639File.WriteAllText(_sdkPropsPath, _sdkPropsContent); 640File.WriteAllText(_sdkTargetsPath, _sdkTargetsContent);

131File.WriteAllText(projectPath, projectContent); 164File.WriteAllText(projectPath, projectContent); 226File.WriteAllText(projectPath, projectContent); 237File.WriteAllText(sdkPropsPath, sdkImportContents); 314File.WriteAllText(projectPath, projectContent); 325File.WriteAllText(sdk1PropsPath, sdk1ImportContents); 336File.WriteAllText(sdk2PropsPath, sdk2ImportContents); 406File.WriteAllText(projectPath, projectContent); 417File.WriteAllText(sdkPropsPath, sdkPropsContents); 427File.WriteAllText(sdkTargetsPath, sdkTargetsContents); 483File.WriteAllText(projectPath, projectContent); 524File.WriteAllText(projectPath, projectContent); 530File.WriteAllText(sdkPropsPath, sdkPropsContents); 535File.WriteAllText(sdkTargetsPath, sdkTargetsContents);

290File.Delete(project.FullPath);

107File.WriteAllText(fileThatMustAlwaysExist, "foo"); 124if (File.Exists(fileThatMustAlwaysExist)) 126File.Delete(fileThatMustAlwaysExist);

408using (File.CreateText(file)) { } 419if (File.Exists(file)) 421File.Delete(file);

43string log = File.ReadAllText(logFile); 46File.Delete(logFile); 71File.Delete(log); 96File.Delete(log); 127File.Delete(log); 202File.Delete(log); 230File.Delete(log); 258File.Delete(log); 303File.Delete(log); 327File.Delete(log); 341Assert.False(File.Exists(log)); 415string log = File.ReadAllText(logFile.Path); 519File.Delete(Path.Combine(Directory.GetCurrentDirectory(), "tempura", "mylogfile1.log")); 522File.Delete(Path.Combine(Directory.GetCurrentDirectory(), "mylogfile0.log")); 523File.Delete(Path.Combine(Directory.GetCurrentDirectory(), "mylogfile3.log")); 524File.Delete(Path.Combine(Directory.GetCurrentDirectory(), "mylogfile4.log"));

65File.WriteAllBytes(Path.Combine(testFolder.Path, file), new byte[1]); 108File.WriteAllBytes(fullPath, new byte[1]); 1242File.WriteAllText(fileName, "Hello there."); 1262File.AppendAllText(workingPathSubdirBing, "y");

201File.Delete(file); 546File.Delete(path); 755Assert.True(File.Exists(path)); 760File.Delete(path); 777Assert.True(File.Exists(path)); 782File.Delete(path); 800Assert.True(File.Exists(path)); 805File.Delete(path); 823Assert.True(File.Exists(path)); 828File.Delete(path); 902File.Delete(filePath); 933File.Delete(filePath);

532File.WriteAllText(rootProjectFile, projectContents); 533File.WriteAllText(declaredReferenceFile, _declaredReference); 534File.WriteAllText(undeclaredReferenceFile, _undeclaredReference);

142File.Exists(outputCache).ShouldBeTrue();

34File.WriteAllText(file, ObjectModelHelpers.CleanupFileContents(@" 52File.Delete(file); 66File.WriteAllText(file, ObjectModelHelpers.CleanupFileContents(@" 84File.Delete(file);

115using (XmlReader xr = XmlReader.Create(File.OpenRead(potentialVersionsPropsPath), xrs))

73File.Exists(originalTaskDllPath).ShouldBeTrue(); 74File.Exists(originalDependencyDllPath).ShouldBeTrue(); 78File.Copy(originalTaskDllPath, newTaskDllPath); 79File.Copy(originalDependencyDllPath, newDependencyDllPath); 81File.Exists(newTaskDllPath).ShouldBeTrue(); 82File.Exists(newDependencyDllPath).ShouldBeTrue(); 86File.Move(originalTaskDllPath, newTaskDllPath); 87File.Move(originalDependencyDllPath, newDependencyDllPath); 90File.Exists(newTaskDllPath).ShouldBeTrue(); 91File.Exists(newDependencyDllPath).ShouldBeTrue(); 92File.Exists(originalTaskDllPath).ShouldBeFalse(); 93File.Exists(originalDependencyDllPath).ShouldBeFalse();

109File.Copy(utilities, Path.Combine(folder.Path, utilitiesName)); 110File.Copy(currentAssembly, newAssemblyLocation); 176Assert.True(File.Exists(originalDllPath)); 180File.Copy(originalDllPath, newDllPath); 182Assert.True(File.Exists(newDllPath)); 186File.Move(originalDllPath, newDllPath); 188Assert.True(File.Exists(newDllPath)); 189Assert.False(File.Exists(originalDllPath)); 203File.Delete(newDllPath); 205Assert.False(File.Exists(newDllPath));

96foreach (string line in File.ReadLines(outputFile.Path))

1212return File.Exists(path) 1213? File.GetLastWriteTimeUtc(path) 1854: File.Exists(fullPath); 1869: File.Exists(path) || Directory.Exists(path);

115using (XmlReader xr = XmlReader.Create(File.OpenRead(potentialVersionsPropsPath), xrs))

36if (!File.Exists(SourcePath)) 42if (File.Exists(DestinationPath)) 70Log.LogMessageFromResources(MessageImportance.Low, "CopyRefAssembly_Changed", SourcePath, File.GetLastWriteTimeUtc(SourcePath).ToString("O"), source, DestinationPath, File.GetLastWriteTimeUtc(DestinationPath).ToString("O"), destination); 87File.Copy(SourcePath, DestinationPath, overwrite: true); 101using (FileStream source = File.OpenRead(path))

117if (File.Exists(targetFileName)) 119string existingContents = File.ReadAllText(targetFileName); 126File.WriteAllText(targetFileName, ConfigFileContents, encoding);

1157if (!File.Exists(reference.ItemSpec))

126File.Delete(path);

328File.Move(actualPdbInfo.FullName, desiredLocation);

437if (!File.Exists(processFilePath)) 458if (!File.Exists(serverInfo.processFilePath)) 720if (!File.Exists(FilePath)) 750File.Delete(FilePath);

64if (File.Exists(filePath))

36if (!File.Exists(SourcePath)) 42if (File.Exists(DestinationPath)) 70Log.LogMessageFromResources(MessageImportance.Low, "CopyRefAssembly_Changed", SourcePath, File.GetLastWriteTimeUtc(SourcePath).ToString("O"), source, DestinationPath, File.GetLastWriteTimeUtc(DestinationPath).ToString("O"), destination); 87File.Copy(SourcePath, DestinationPath, overwrite: true); 101using (FileStream source = File.OpenRead(path))

117if (File.Exists(targetFileName)) 119string existingContents = File.ReadAllText(targetFileName); 126File.WriteAllText(targetFileName, ConfigFileContents, encoding);

1157if (!File.Exists(reference.ItemSpec))

126File.Delete(path);

328File.Move(actualPdbInfo.FullName, desiredLocation);

437if (!File.Exists(processFilePath)) 458if (!File.Exists(serverInfo.processFilePath)) 720if (!File.Exists(FilePath)) 750File.Delete(FilePath);

64if (File.Exists(filePath))

47File.WriteAllText(file.Path, ""); 65File.WriteAllText(file.Path, "test"); 77Assert.Equal("test", File.ReadAllText(dest)); 85File.WriteAllText(source.Path, "test"); 87File.WriteAllText(dest.Path, "dest"); 104Assert.Equal("test", File.ReadAllText(dest.Path)); 112File.WriteAllBytes(source.Path, TestResources.General.MVID1); 113var sourceTimestamp = File.GetLastWriteTimeUtc(source.Path).ToString("O"); 116File.WriteAllBytes(dest.Path, TestResources.General.MVID2); 117var destTimestamp = File.GetLastWriteTimeUtc(dest.Path).ToString("O");

113File.ReadAllText(sourceLinkJsonPath)); 152File.ReadAllText(sourceLinkJsonPath)); 190File.ReadAllText(sourceLinkJsonPath)); 228File.ReadAllText(sourceLinkJsonPath)); 268File.ReadAllText(sourceLinkJsonPath)); 308File.ReadAllText(sourceLinkJsonPath));

376Assert.True(File.Exists(fileName)); 378Assert.Equal(expectedContents, File.ReadAllText(fileName));

73=> dotnetDir != null && File.Exists(Path.Combine(dotnetDir, s_dotnetExeName)) && Directory.Exists(GetSdkPath(dotnetDir, s_dotnetSdkVersion)); 99File.WriteAllText(filePath, 117File.WriteAllText(filePath, 177Assert.True(File.Exists(csharpCoreTargets)); 178Assert.True(File.Exists(visualBasicCoreTargets)); 196Assert.True(File.Exists(Path.Combine(ObjDir.Path, "project.assets.json"))); 197Assert.True(File.Exists(Path.Combine(ObjDir.Path, ProjectFileName + ".nuget.g.props"))); 198Assert.True(File.Exists(Path.Combine(ObjDir.Path, ProjectFileName + ".nuget.g.targets"))); 237var evaluationResult = File.ReadAllLines(evaluationResultsFile).Select(l => (l != EmptyValueMarker) ? l : "");

92if (string.IsNullOrEmpty(ApplicationManifest.ItemSpec) || !File.Exists(ApplicationManifest?.ItemSpec)) 112: File.OpenRead(path);

36FileStream fs = File.OpenRead(appConfigFilePath);

450using (var stream = File.OpenRead(_sourceFile)) 977using Stream stream = File.OpenRead(path);

340using (XmlReader xr = XmlReader.Create(File.OpenRead(appConfigItem.ItemSpec), xrs))

372File.Copy(setupSourceFile, strOutputExe, true); 543FileStream fs = File.OpenRead(resourceFilePath); 1478File.Copy(packageFileSource.Value, strDestinationFileName, true); 1590FileAttributes attribs = File.GetAttributes(strFileName); 1594File.SetAttributes(strFileName, attribs);

99using (FileStream fs = File.OpenRead(resource.Filename))

609var existsCheck = mode == BuildEnvironmentMode.VisualStudio ? new Func<string, bool>(_ => true) : File.Exists;

375File.Copy(sourceFileState.Name, destinationFileState.Name, true); 416File.SetAttributes(file.Name, FileAttributes.Normal);

192if (File.Exists(Path.Combine(Path.GetDirectoryName(fileName), conventionDependentUpon)))

115while (File.Exists(fullPath))

134File.Delete(file.ItemSpec);

68lastModified = File.GetLastWriteTime(FileName);

394if (File.GetLastWriteTimeUtc(file) >= fromTimeUtc) 400builder.Append(File.ReadAllText(file));

143using (var stream = File.OpenRead(filePath))

45string[] textLines = System.IO.File.ReadAllLines(File.ItemSpec);

113string existingContents = System.IO.File.ReadAllText(File.ItemSpec); 137System.IO.File.WriteAllText(File.ItemSpec, contentsAsString, encoding); 147System.IO.File.AppendAllText(File.ItemSpec, buffer.ToString(), encoding);

81return !File.Exists(lowerCased); 198File.WriteAllText(testFilePath, $"MSBuild process {EnvironmentUtilities.CurrentProcessId} successfully wrote to file."); 199File.Delete(testFilePath); 894File.Delete(FixFilePath(path));

451using (Stream s = File.Open(InputManifest.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read))

2886File.Delete(filename); 3566using var fs = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);

968File.Delete(existingCacheFile); 1088DateTime referencesCacheFileLastWriteTimeUtc = File.GetLastWriteTimeUtc(referencesCacheFile); 1099DateTime currentCodeLastWriteTime = File.GetLastWriteTimeUtc(codeBase.LocalPath);

51return File.ReadAllText(path); 56return File.ReadAllBytes(path); 131return File.GetAttributes(path); 136return File.GetLastWriteTimeUtc(path); 146return File.Exists(path);

530FileStream fs = File.OpenRead(configFile.ResolvedPath);

208FileStream fs = File.OpenRead(path);

217FileStream fs = File.OpenRead(redistListFilePath);

92File.Copy(LauncherPath, strOutputExe, true); 114FileAttributes attribs = File.GetAttributes(strFileName); 118File.SetAttributes(strFileName, attribs);

379FileStream fs = File.OpenRead(inputPath);

54using (Stream s = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)) 138using (Stream s = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))

56using (Stream s = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Write)) 70using (Stream s = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Write)) 133File.Copy(temp, Path.Combine(Util.logPath, n + ".trust-file.xml"), true); 156File.Delete(temp); 181File.Delete(temp);

167using (Stream s = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))

698FileStream fs = File.OpenRead(path);

435using (Stream s = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)) 474using (Stream s = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)) 547using (Stream s = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None)) 637File.Delete(tempPrivilegeDocument); 655s = File.Open(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None); 659s = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None);

331modifiedItemSpec = File.GetCreationTime(unescapedItemSpec).ToString(FileTimeFormat, null); 347modifiedItemSpec = File.GetLastAccessTime(unescapedItemSpec).ToString(FileTimeFormat, null);

262File.Move(sourceFile, destinationFile);

858if (targetExists && (File.GetAttributes(newFileName) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) 870File.Delete(newFileName); 873File.Move(existingFileName, newFileName);

28File.AppendAllText(file, CsvFormat(string.Empty, callsite, args)); 33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

663FileStream fs = File.OpenRead(path);

268byte[] byteArray = File.ReadAllBytes(fileName); 277byte[] byteArray = File.ReadAllBytes(fileName);

443taskInfo.SourceCode = File.ReadAllText(sourceAttribute.Value.Trim()); 570.FirstOrDefault(p => File.Exists(Path.Combine(p, assemblyFileName))); 601if (File.Exists(path)) 608if (File.Exists(path)) 693File.WriteAllText(sourceCodePath, taskInfo.SourceCode); 763assembly = Assembly.Load(File.ReadAllBytes(assemblyPath)); 779File.Delete(assemblyPath); 784File.Delete(sourceCodePath);

46return possibleLocations.Select(possibleLocation => possibleLocation()).FirstOrDefault(File.Exists);

47File.Delete(stateFile); 85using (FileStream s = File.OpenRead(stateFile)) 142File.Delete(stateFile);

192File.WriteAllText(file, string.Empty);

152File.Exists, 153File.Create, 154File.GetAttributes, 155File.SetAttributes, 156File.SetLastAccessTime, 157File.SetLastWriteTime);

259using (Stream destination = File.Open(destinationPath.FullName, FileMode.Create, FileAccess.Write, FileShare.None))

72return File.Exists(path);

118File.WriteAllText(OutputFile.ItemSpec, code); // Overwrites file if it already exists (and can be overwritten)

142using (Stream stream = File.Create(XmlInputPath.ItemSpec))

87File.Delete(destinationFile.FullName);

109File.Copy(Path.Combine(TestAssetsRootPath, manifestName), Path.Combine(projectFolder.Path, manifestName));

37if (File.Exists(_rarCacheFile))

834if (File.Exists(path) && useFrameworkFileExists) 2942File.WriteAllText(appConfigFile, appConfigContents); 3001File.WriteAllText(redistListPath, REDISTLIST); 3073File.Delete(t.StateFile); 3099File.Delete(t.StateFile); 3114if (File.Exists(redistListPath)) 3119if (File.Exists(rarCacheFile)) 3154File.WriteAllText( 3164File.Delete(redistFile);

516File.Delete(file); 564File.Delete(source); 624File.Delete(source); 625File.Delete(destination); 677File.Delete(source); 678File.Delete(destination); 705File.SetAttributes(destination, FileAttributes.ReadOnly); 730string destinationContent = File.ReadAllText(destination); 737File.SetAttributes(source, FileAttributes.Normal); 738File.SetAttributes(destination, FileAttributes.Normal); 739File.Delete(source); 740File.Delete(destination); 772File.SetAttributes(destination, FileAttributes.ReadOnly); 797string destinationContent = File.ReadAllText(destination); 806File.Delete(source); 807File.Delete(destination); 839File.SetAttributes(destination, FileAttributes.ReadOnly); 876File.SetAttributes(destination, FileAttributes.Normal); 878File.Delete(source); 879File.Delete(destination); 906File.SetAttributes(destination, FileAttributes.ReadOnly); 931string destinationContent = File.ReadAllText(destination); 938File.Delete(source); 939File.Delete(destination); 980File.SetAttributes(destination1, FileAttributes.ReadOnly); 1003string destinationContent1 = File.ReadAllText(destination1); 1005string destinationContent2 = File.ReadAllText(destination2); 1008Assert.NotEqual(FileAttributes.ReadOnly, File.GetAttributes(destination1) & FileAttributes.ReadOnly); 1009Assert.NotEqual(FileAttributes.ReadOnly, File.GetAttributes(destination2) & FileAttributes.ReadOnly); 1015File.SetAttributes(destination1, FileAttributes.Normal); // just in case 1016File.SetAttributes(destination2, FileAttributes.Normal); // just in case 1017File.Delete(source1); 1018File.Delete(source2); 1019File.Delete(destination1); 1020File.Delete(destination2); 1077File.Delete(sourceFile); 1078File.Delete(destinationFile); 1102File.WriteAllText(sourceFile, "This is a source temp file."); 1151Assert.Equal("This is a source temp file.", File.ReadAllText(destinationFile)); 1185File.Delete(destinationFile); 1200Assert.True(File.Exists(destinationFile)); // "Expected the destination file to exist." 1205File.Delete(sourceFile); 1206File.Delete(destinationFile); 1246File.Delete(sourceFile); 1270File.Delete(destinationFile); 1293File.Delete(destinationFile); 1317File.Delete(destinationFile); 1340File.Delete(destinationFile); 1390File.Delete(sourceFile); 1391File.Delete(destinationFile); 1511File.Delete(sourceFile); 1556File.Delete(sourceFile); 1581fs = File.Create(inFile1); 1582fs2 = File.Create(inFile2); 1642File.Delete(inFile1); 1643File.Delete(inFile2); 1644File.Delete(validOutFile); 1665fs = File.Create(file); 1714File.Delete(file); 1736fs = File.Create(file); 1765File.Delete(file); 1790fs = File.Create(file); 1832File.Delete(file); 1873Assert.True(File.Exists(destFile)); // "destination exists" 1945Assert.True(File.Exists(destFile)); // "destination exists" 2122fs = File.Create(inFile1); 2123fs2 = File.Create(inFile2); 2147Assert.False(File.Exists(outFile1)); 2153File.Delete(inFile1); 2154File.Delete(inFile2); 2155File.Delete(outFile1); 2199File.Delete(sourceFile); 2213File.Delete(destinationFile); 2232Assert.False(File.Exists(destinationFile)); 2522File.SetAttributes(existing, FileAttributes.ReadOnly); 2553File.WriteAllText(sourceFile, "This is a source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2573Assert.True(File.Exists(destFile)); // "destination exists" 2578string destinationFileContents = File.ReadAllText(destFile); 2589File.WriteAllText(sourceFile, "This is another source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2592destinationFileContents = File.ReadAllText(destFile); 2627File.WriteAllText(nothingFile, "nothing"); 2628File.Delete(nothingFile); 2640File.WriteAllText(sourceFile1, "This is source temp file 1."); // HIGHCHAR: Test writes in UTF8 without preamble. 2641File.WriteAllText(sourceFile2, "This is source temp file 2."); 2663Assert.True(File.Exists(destFile1)); // "destination exists" 2664Assert.True(File.Exists(destFile2)); // "destination exists" 2675string destinationFileContents = File.ReadAllText(destFile1); 2677destinationFileContents = File.ReadAllText(destFile2); 2690File.WriteAllText(sourceFile1, "This is another source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2693destinationFileContents = File.ReadAllText(destFile1); 2700File.Delete(sourceFile1); 2701File.Delete(sourceFile2); 2702File.Delete(destFile1); 2703File.Delete(destFile2); 2728File.WriteAllText(sourceFile, "This is a source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2759Assert.True(File.Exists(destFile)); // "destination exists" 2770string destinationFileContents = File.ReadAllText(destFile); 2781File.WriteAllText(sourceFile, "This is another source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2784destinationFileContents = File.ReadAllText(destFile); 2791File.Delete(sourceFile); 2792File.Delete(destFile); 2809File.WriteAllText(sourceFile, "This is a source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2828Assert.True(File.Exists(destFile)); // "destination exists" 2829Assert.True((File.GetAttributes(destFile) & FileAttributes.ReparsePoint) != 0, "File was copied but is not a symlink"); 2835string destinationFileContents = File.ReadAllText(destFile); 2847File.WriteAllText(sourceFile, "This is another source temp file."); // HIGHCHAR: Test writes in UTF8 without preamble. 2850destinationFileContents = File.ReadAllText(destFile); 2857File.Delete(sourceFile); 2858File.Delete(destFile); 2959File.Exists(destFile).ShouldBeTrue(); 2960File.ReadAllText(destFile).ShouldBe("This is the first source temp file."); 2976File.Exists(destFile).ShouldBeTrue(); 2977File.ReadAllText(destFile).ShouldBe("This is the second source temp file."); 2980File.ReadAllText(sourceFile1.Path).ShouldBe("This is the first source temp file."); 2997File.Exists(sourceFile2.Path).ShouldBeTrue();

55File.SetAttributes(source, FileAttributes.ReadOnly); 74File.SetAttributes(source, FileAttributes.Normal); 88File.Delete(source);

81File.ReadAllText(file.FullName).ShouldBe("Success!"); 126File.ReadAllText(file.FullName).ShouldBe("Success!"); 160File.ReadAllText(file.FullName).ShouldBe("Success!");

587File.WriteAllText(command, "echo [hello]");

69File.Delete(file); 88File.Delete(file); 115File.Delete(file); 134File.Delete(file); 153File.Delete(file); 172File.Delete(file); 188File.Delete(file); 195if (File.Exists(file)) 197File.Delete(file); 217File.Move(oldFile, file); 224File.Delete(file); 250File.Delete(file); 276File.Delete(file); 294File.WriteAllText(file, "x"); 303File.Delete(file); 326File.Delete(file);